Skip to content

Commit 685980c

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.2260
No.2260.Minimum Consecutive Cards to Pick Up
1 parent bf519ce commit 685980c

File tree

7 files changed

+123
-135
lines changed

7 files changed

+123
-135
lines changed

‎solution/2200-2299/2260.Minimum Consecutive Cards to Pick Up/README.md

+45-45
Original file line numberDiff line numberDiff line change
@@ -37,6 +37,12 @@
3737

3838
<!-- 这里可写通用的实现逻辑 -->
3939

40+
**方法一：哈希表**
41+
42+
我们初始化答案为 $+\infty$，遍历数组，对于每个数字 $x$，如果 $last[x]$ 存在，则表示 $x$ 有一对匹配卡牌，此时更新答案为 $ans = min(ans, i - last[x] + 1)$，最后如果答案为 $+\infty$，则返回 $-1$，否则返回答案。
43+
44+
时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组长度。
45+
4046
<!-- tabs:start -->
4147

4248
### **Python3**
@@ -46,13 +52,13 @@
4652
```python
4753
class Solution:
4854
def minimumCardPickup(self, cards: List[int]) -> int:
49-
m = {}
50-
ans = 10**6
51-
for i, c in enumerate(cards):
52-
if c in m:
53-
ans = min(ans, i - m[c] + 1)
54-
m[c] = i
55-
return -1 if ans == 10**6 else ans
55+
last = {}
56+
ans = inf
57+
for i, x in enumerate(cards):
58+
if x in last:
59+
ans = min(ans, i - last[x] + 1)
60+
last[x] = i
61+
return -1 if ans == inf else ans
5662
```
5763

5864
### **Java**
@@ -62,16 +68,16 @@ class Solution:
6268
```java
6369
class Solution {
6470
public int minimumCardPickup(int[] cards) {
65-
Map<Integer, Integer> m = new HashMap<>();
66-
int ans = 1000000;
67-
for (int i = 0; i < cards.length; ++i) {
68-
int c = cards[i];
69-
if (m.containsKey(c)) {
70-
ans = Math.min(ans, i - m.get(c) + 1);
71+
Map<Integer, Integer> last = new HashMap<>();
72+
int n = cards.length;
73+
int ans = n + 1;
74+
for (int i = 0; i < n; ++i) {
75+
if (last.containsKey(cards[i])) {
76+
ans = Math.min(ans, i - last.get(cards[i]) + 1);
7177
}
72-
m.put(c, i);
78+
last.put(cards[i], i);
7379
}
74-
return ans == 1000000 ? -1 : ans;
80+
return ans > n ? -1 : ans;
7581
}
7682
}
7783
```
@@ -82,14 +88,16 @@ class Solution {
8288
class Solution {
8389
public:
8490
int minimumCardPickup(vector<int>& cards) {
85-
unordered_map<int, int> m;
86-
int ans = 1e6;
87-
for (int i = 0; i < cards.size(); ++i) {
88-
int c = cards[i];
89-
if (m.count(c)) ans = min(ans, i - m[c] + 1);
90-
m[c] = i;
91+
unordered_map<int, int> last;
92+
int n = cards.size();
93+
int ans = n + 1;
94+
for (int i = 0; i < n; ++i) {
95+
if (last.count(cards[i])) {
96+
ans = min(ans, i - last[cards[i]] + 1);
97+
}
98+
last[cards[i]] = i;
9199
}
92-
return ans == 1e6 ? -1 : ans;
100+
return ans > n ? -1 : ans;
93101
}
94102
};
95103
```
@@ -98,44 +106,36 @@ public:
98106
99107
```go
100108
func minimumCardPickup(cards []int) int {
101-
m := map[int]int{}
102-
ans := 1000000
103-
for i, c := range cards {
104-
if j, ok := m[c]; ok {
105-
ans = min(ans, i-j+1)
109+
last := map[int]int{}
110+
n := len(cards)
111+
ans := n + 1
112+
for i, x := range cards {
113+
if j, ok := last[x]; ok && ans > i-j+1 {
114+
ans = i - j + 1
106115
}
107-
m[c] = i
116+
last[x] = i
108117
}
109-
if ans == 1000000 {
118+
if ans > n {
110119
return -1
111120
}
112121
return ans
113122
}
114-
115-
func min(a, b int) int {
116-
if a < b {
117-
return a
118-
}
119-
return b
120-
}
121123
```
122124

123125
### **TypeScript**
124126

125127
```ts
126128
function minimumCardPickup(cards: number[]): number {
127129
const n = cards.length;
128-
let hashMap = new Map<number, number>();
129-
const max = Number.MAX_SAFE_INTEGER;
130-
let ans = max;
131-
for (let i = 0; i < n; i++) {
132-
let num = cards[i];
133-
if (hashMap.has(num)) {
134-
ans = Math.min(i - hashMap.get(num) + 1, ans);
130+
const last = new Map<number, number>();
131+
let ans = n + 1;
132+
for (let i = 0; i < n; ++i) {
133+
if (last.has(cards[i])) {
134+
ans = Math.min(ans, i - last.get(cards[i]) + 1);
135135
}
136-
hashMap.set(num, i);
136+
last.set(cards[i], i);
137137
}
138-
return ans == max ? -1 : ans;
138+
return ans > n ? -1 : ans;
139139
}
140140
```
141141

‎solution/2200-2299/2260.Minimum Consecutive Cards to Pick Up/README_EN.md

+39-45
Original file line numberDiff line numberDiff line change
@@ -42,30 +42,30 @@
4242
```python
4343
class Solution:
4444
def minimumCardPickup(self, cards: List[int]) -> int:
45-
m = {}
46-
ans = 10**6
47-
for i, c in enumerate(cards):
48-
if c in m:
49-
ans = min(ans, i - m[c] + 1)
50-
m[c] = i
51-
return -1 if ans == 10**6 else ans
45+
last = {}
46+
ans = inf
47+
for i, x in enumerate(cards):
48+
if x in last:
49+
ans = min(ans, i - last[x] + 1)
50+
last[x] = i
51+
return -1 if ans == inf else ans
5252
```
5353

5454
### **Java**
5555

5656
```java
5757
class Solution {
5858
public int minimumCardPickup(int[] cards) {
59-
Map<Integer, Integer> m = new HashMap<>();
60-
int ans = 1000000;
61-
for (int i = 0; i < cards.length; ++i) {
62-
int c = cards[i];
63-
if (m.containsKey(c)) {
64-
ans = Math.min(ans, i - m.get(c) + 1);
59+
Map<Integer, Integer> last = new HashMap<>();
60+
int n = cards.length;
61+
int ans = n + 1;
62+
for (int i = 0; i < n; ++i) {
63+
if (last.containsKey(cards[i])) {
64+
ans = Math.min(ans, i - last.get(cards[i]) + 1);
6565
}
66-
m.put(c, i);
66+
last.put(cards[i], i);
6767
}
68-
return ans == 1000000 ? -1 : ans;
68+
return ans > n ? -1 : ans;
6969
}
7070
}
7171
```
@@ -76,14 +76,16 @@ class Solution {
7676
class Solution {
7777
public:
7878
int minimumCardPickup(vector<int>& cards) {
79-
unordered_map<int, int> m;
80-
int ans = 1e6;
81-
for (int i = 0; i < cards.size(); ++i) {
82-
int c = cards[i];
83-
if (m.count(c)) ans = min(ans, i - m[c] + 1);
84-
m[c] = i;
79+
unordered_map<int, int> last;
80+
int n = cards.size();
81+
int ans = n + 1;
82+
for (int i = 0; i < n; ++i) {
83+
if (last.count(cards[i])) {
84+
ans = min(ans, i - last[cards[i]] + 1);
85+
}
86+
last[cards[i]] = i;
8587
}
86-
return ans == 1e6 ? -1 : ans;
88+
return ans > n ? -1 : ans;
8789
}
8890
};
8991
```
@@ -92,44 +94,36 @@ public:
9294
9395
```go
9496
func minimumCardPickup(cards []int) int {
95-
m := map[int]int{}
96-
ans := 1000000
97-
for i, c := range cards {
98-
if j, ok := m[c]; ok {
99-
ans = min(ans, i-j+1)
97+
last := map[int]int{}
98+
n := len(cards)
99+
ans := n + 1
100+
for i, x := range cards {
101+
if j, ok := last[x]; ok && ans > i-j+1 {
102+
ans = i - j + 1
100103
}
101-
m[c] = i
104+
last[x] = i
102105
}
103-
if ans == 1000000 {
106+
if ans > n {
104107
return -1
105108
}
106109
return ans
107110
}
108-
109-
func min(a, b int) int {
110-
if a < b {
111-
return a
112-
}
113-
return b
114-
}
115111
```
116112

117113
### **TypeScript**
118114

119115
```ts
120116
function minimumCardPickup(cards: number[]): number {
121117
const n = cards.length;
122-
let hashMap = new Map<number, number>();
123-
const max = Number.MAX_SAFE_INTEGER;
124-
let ans = max;
125-
for (let i = 0; i < n; i++) {
126-
let num = cards[i];
127-
if (hashMap.has(num)) {
128-
ans = Math.min(i - hashMap.get(num) + 1, ans);
118+
const last = new Map<number, number>();
119+
let ans = n + 1;
120+
for (let i = 0; i < n; ++i) {
121+
if (last.has(cards[i])) {
122+
ans = Math.min(ans, i - last.get(cards[i]) + 1);
129123
}
130-
hashMap.set(num, i);
124+
last.set(cards[i], i);
131125
}
132-
return ans == max ? -1 : ans;
126+
return ans > n ? -1 : ans;
133127
}
134128
```
135129

‎solution/2200-2299/2260.Minimum Consecutive Cards to Pick Up/Solution.cpp

+9-7
Original file line numberDiff line numberDiff line change
@@ -1,13 +1,15 @@
11
class Solution {
22
public:
33
int minimumCardPickup(vector<int>& cards) {
4-
unordered_map<int, int> m;
5-
int ans = 1e6;
6-
for (int i = 0; i < cards.size(); ++i) {
7-
int c = cards[i];
8-
if (m.count(c)) ans = min(ans, i - m[c] + 1);
9-
m[c] = i;
4+
unordered_map<int, int> last;
5+
int n = cards.size();
6+
int ans = n + 1;
7+
for (int i = 0; i < n; ++i) {
8+
if (last.count(cards[i])) {
9+
ans = min(ans, i - last[cards[i]] + 1);
10+
}
11+
last[cards[i]] = i;
1012
}
11-
return ans == 1e6 ? -1 : ans;
13+
return ans > n ? -1 : ans;
1214
}
1315
};

‎solution/2200-2299/2260.Minimum Consecutive Cards to Pick Up/Solution.go

+8-14
Original file line numberDiff line numberDiff line change
@@ -1,21 +1,15 @@
11
func minimumCardPickup(cards []int) int {
2-
m := map[int]int{}
3-
ans := 1000000
4-
for i, c := range cards {
5-
if j, ok := m[c]; ok {
6-
ans = min(ans, i-j+1)
2+
last := map[int]int{}
3+
n := len(cards)
4+
ans := n + 1
5+
for i, x := range cards {
6+
if j, ok := last[x]; ok && ans > i-j+1 {
7+
ans = i - j + 1
78
}
8-
m[c] = i
9+
last[x] = i
910
}
10-
if ans == 1000000 {
11+
if ans > n {
1112
return -1
1213
}
1314
return ans
14-
}
15-
16-
func min(a, b int) int {
17-
if a < b {
18-
return a
19-
}
20-
return b
2115
}

‎solution/2200-2299/2260.Minimum Consecutive Cards to Pick Up/Solution.java

+8-8
Original file line numberDiff line numberDiff line change
@@ -1,14 +1,14 @@
11
class Solution {
22
public int minimumCardPickup(int[] cards) {
3-
Map<Integer, Integer> m = new HashMap<>();
4-
int ans = 1000000;
5-
for (int i = 0; i < cards.length; ++i) {
6-
int c = cards[i];
7-
if (m.containsKey(c)) {
8-
ans = Math.min(ans, i - m.get(c) + 1);
3+
Map<Integer, Integer> last = new HashMap<>();
4+
int n = cards.length;
5+
int ans = n + 1;
6+
for (int i = 0; i < n; ++i) {
7+
if (last.containsKey(cards[i])) {
8+
ans = Math.min(ans, i - last.get(cards[i]) + 1);
99
}
10-
m.put(c, i);
10+
last.put(cards[i], i);
1111
}
12-
return ans == 1000000 ? -1 : ans;
12+
return ans > n ? -1 : ans;
1313
}
1414
}

‎solution/2200-2299/2260.Minimum Consecutive Cards to Pick Up/Solution.py

+7-7
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,9 @@
11
class Solution:
22
def minimumCardPickup(self, cards: List[int]) -> int:
3-
m = {}
4-
ans = 10**6
5-
for i, c in enumerate(cards):
6-
if c in m:
7-
ans = min(ans, i - m[c] + 1)
8-
m[c] = i
9-
return -1 if ans == 10**6 else ans
3+
last = {}
4+
ans = inf
5+
for i, x in enumerate(cards):
6+
if x in last:
7+
ans = min(ans, i - last[x] + 1)
8+
last[x] = i
9+
return -1 if ans == inf else ans

‎solution/2200-2299/2260.Minimum Consecutive Cards to Pick Up/Solution.ts

+7-9
Original file line numberDiff line numberDiff line change
@@ -1,14 +1,12 @@
11
function minimumCardPickup(cards: number[]): number {
22
const n = cards.length;
3-
let hashMap = new Map<number, number>();
4-
const max = Number.MAX_SAFE_INTEGER;
5-
let ans = max;
6-
for (let i = 0; i < n; i++) {
7-
let num = cards[i];
8-
if (hashMap.has(num)) {
9-
ans = Math.min(i - hashMap.get(num) + 1, ans);
3+
const last = new Map<number, number>();
4+
let ans = n + 1;
5+
for (let i = 0; i < n; ++i) {
6+
if (last.has(cards[i])) {
7+
ans = Math.min(ans, i - last.get(cards[i]) + 1);
108
}
11-
hashMap.set(num, i);
9+
last.set(cards[i], i);
1210
}
13-
return ans == max ? -1 : ans;
11+
return ans > n ? -1 : ans;
1412
}

0 commit comments

Comments
 (0)