Skip to content

Commit 61dc42c

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0697
No.0697.Degree of an Array
1 parent b801031 commit 61dc42c

File tree

5 files changed

+248
-106
lines changed

5 files changed

+248
-106
lines changed

‎solution/0600-0699/0697.Degree of an Array/README.md

Lines changed: 96 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -47,8 +47,12 @@
4747

4848
<!-- 这里可写通用的实现逻辑 -->
4949

50+
**方法一：哈希表**
51+
5052
遍历数组，用哈希表记录数组每个元素出现的次数，以及首次、末次出现的位置。然后遍历哈希表，获取元素出现次数最多（可能有多个）且首末位置差最小的数。
5153

54+
时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组长度。
55+
5256
<!-- tabs:start -->
5357

5458
### **Python3**
@@ -58,23 +62,20 @@
5862
```python
5963
class Solution:
6064
def findShortestSubArray(self, nums: List[int]) -> int:
61-
mapper = {}
65+
cnt = Counter(nums)
66+
degree = cnt.most_common()[0][1]
67+
left, right = {}, {}
6268
for i, v in enumerate(nums):
63-
if v in mapper:
64-
arr = mapper[v]
65-
arr[0] += 1
66-
arr[2] = i
67-
else:
68-
arr = [1, i, i]
69-
mapper[v] = arr
70-
max_degree = min_len = 0
71-
for arr in mapper.values():
72-
if max_degree < arr[0]:
73-
max_degree = arr[0]
74-
min_len = arr[2] - arr[1] + 1
75-
elif max_degree == arr[0]:
76-
min_len = min(min_len, arr[2] - arr[1] + 1)
77-
return min_len
69+
if v not in left:
70+
left[v] = i
71+
right[v] = i
72+
ans = inf
73+
for v in nums:
74+
if cnt[v] == degree:
75+
t = right[v] - left[v] + 1
76+
if ans > t:
77+
ans = t
78+
return ans
7879
```
7980

8081
### **Java**
@@ -84,36 +85,95 @@ class Solution:
8485
```java
8586
class Solution {
8687
public int findShortestSubArray(int[] nums) {
87-
Map<Integer, int[]> mapper = new HashMap<>();
88-
for (int i = 0, n = nums.length; i < n; ++i) {
89-
if (mapper.containsKey(nums[i])) {
90-
int[] arr = mapper.get(nums[i]);
91-
++arr[0];
92-
arr[2] = i;
93-
} else {
94-
int[] arr = new int[] {1, i, i};
95-
mapper.put(nums[i], arr);
88+
Map<Integer, Integer> cnt = new HashMap<>();
89+
Map<Integer, Integer> left = new HashMap<>();
90+
Map<Integer, Integer> right = new HashMap<>();
91+
int degree = 0;
92+
for (int i = 0; i < nums.length; ++i) {
93+
int v = nums[i];
94+
cnt.put(v, cnt.getOrDefault(v, 0) + 1);
95+
degree = Math.max(degree, cnt.get(v));
96+
if (!left.containsKey(v)) {
97+
left.put(v, i);
9698
}
99+
right.put(v, i);
97100
}
98-
99-
int maxDegree = 0, minLen = 0;
100-
for (Map.Entry<Integer, int[]> entry : mapper.entrySet()) {
101-
int[] arr = entry.getValue();
102-
if (maxDegree < arr[0]) {
103-
maxDegree = arr[0];
104-
minLen = arr[2] - arr[1] + 1;
105-
} else if (maxDegree == arr[0]) {
106-
minLen = Math.min(minLen, arr[2] - arr[1] + 1);
101+
int ans = 1000000;
102+
for (int v : nums) {
103+
if (cnt.get(v) == degree) {
104+
int t = right.get(v) - left.get(v) + 1;
105+
if (ans > t) {
106+
ans = t;
107+
}
107108
}
108109
}
109-
return minLen;
110+
return ans;
110111
}
111112
}
112113
```
113114

115+
### **C++**
116+
117+
```cpp
118+
class Solution {
119+
public:
120+
int findShortestSubArray(vector<int>& nums) {
121+
unordered_map<int, int> cnt;
122+
unordered_map<int, int> left;
123+
unordered_map<int, int> right;
124+
int degree = 0;
125+
for (int i = 0; i < nums.size(); ++i) {
126+
int v = nums[i];
127+
degree = max(degree, ++cnt[v]);
128+
if (!left.count(v)) {
129+
left[v] = i;
130+
}
131+
right[v] = i;
132+
}
133+
int ans = 1e6;
134+
for (int v : nums) {
135+
if (cnt[v] == degree) {
136+
int t = right[v] - left[v] + 1;
137+
if (ans > t) {
138+
ans = t;
139+
}
140+
}
141+
}
142+
return ans;
143+
}
144+
};
145+
```
146+
114147
### **Go**
115148
116-
<!-- 这里可写当前语言的特殊实现逻辑 -->
149+
```go
150+
func findShortestSubArray(nums []int) int {
151+
cnt := map[int]int{}
152+
left := map[int]int{}
153+
right := map[int]int{}
154+
var degree int
155+
for i, v := range nums {
156+
cnt[v]++
157+
if degree < cnt[v] {
158+
degree = cnt[v]
159+
}
160+
if _, ok := left[v]; !ok {
161+
left[v] = i
162+
}
163+
right[v] = i
164+
}
165+
ans := 100000
166+
for v, c := range cnt {
167+
if c == degree {
168+
t := right[v] - left[v] + 1
169+
if ans > t {
170+
ans = t
171+
}
172+
}
173+
}
174+
return ans
175+
}
176+
```
117177

118178
```go
119179
func findShortestSubArray(nums []int) (ans int) {

‎solution/0600-0699/0697.Degree of an Array/README_EN.md

Lines changed: 93 additions & 35 deletions
Original file line numberDiff line numberDiff line change
@@ -48,59 +48,117 @@ So [2,2,3,1,4,2] is the shortest subarray, therefore returning 6.
4848
```python
4949
class Solution:
5050
def findShortestSubArray(self, nums: List[int]) -> int:
51-
mapper = {}
51+
cnt = Counter(nums)
52+
degree = cnt.most_common()[0][1]
53+
left, right = {}, {}
5254
for i, v in enumerate(nums):
53-
if v in mapper:
54-
arr = mapper[v]
55-
arr[0] += 1
56-
arr[2] = i
57-
else:
58-
arr = [1, i, i]
59-
mapper[v] = arr
60-
max_degree = min_len = 0
61-
for arr in mapper.values():
62-
if max_degree < arr[0]:
63-
max_degree = arr[0]
64-
min_len = arr[2] - arr[1] + 1
65-
elif max_degree == arr[0]:
66-
min_len = min(min_len, arr[2] - arr[1] + 1)
67-
return min_len
55+
if v not in left:
56+
left[v] = i
57+
right[v] = i
58+
ans = inf
59+
for v in nums:
60+
if cnt[v] == degree:
61+
t = right[v] - left[v] + 1
62+
if ans > t:
63+
ans = t
64+
return ans
6865
```
6966

7067
### **Java**
7168

7269
```java
7370
class Solution {
7471
public int findShortestSubArray(int[] nums) {
75-
Map<Integer, int[]> mapper = new HashMap<>();
76-
for (int i = 0, n = nums.length; i < n; ++i) {
77-
if (mapper.containsKey(nums[i])) {
78-
int[] arr = mapper.get(nums[i]);
79-
++arr[0];
80-
arr[2] = i;
81-
} else {
82-
int[] arr = new int[] {1, i, i};
83-
mapper.put(nums[i], arr);
72+
Map<Integer, Integer> cnt = new HashMap<>();
73+
Map<Integer, Integer> left = new HashMap<>();
74+
Map<Integer, Integer> right = new HashMap<>();
75+
int degree = 0;
76+
for (int i = 0; i < nums.length; ++i) {
77+
int v = nums[i];
78+
cnt.put(v, cnt.getOrDefault(v, 0) + 1);
79+
degree = Math.max(degree, cnt.get(v));
80+
if (!left.containsKey(v)) {
81+
left.put(v, i);
8482
}
83+
right.put(v, i);
8584
}
86-
87-
int maxDegree = 0, minLen = 0;
88-
for (Map.Entry<Integer, int[]> entry : mapper.entrySet()) {
89-
int[] arr = entry.getValue();
90-
if (maxDegree < arr[0]) {
91-
maxDegree = arr[0];
92-
minLen = arr[2] - arr[1] + 1;
93-
} else if (maxDegree == arr[0]) {
94-
minLen = Math.min(minLen, arr[2] - arr[1] + 1);
85+
int ans = 1000000;
86+
for (int v : nums) {
87+
if (cnt.get(v) == degree) {
88+
int t = right.get(v) - left.get(v) + 1;
89+
if (ans > t) {
90+
ans = t;
91+
}
9592
}
9693
}
97-
return minLen;
94+
return ans;
9895
}
9996
}
10097
```
10198

99+
### **C++**
100+
101+
```cpp
102+
class Solution {
103+
public:
104+
int findShortestSubArray(vector<int>& nums) {
105+
unordered_map<int, int> cnt;
106+
unordered_map<int, int> left;
107+
unordered_map<int, int> right;
108+
int degree = 0;
109+
for (int i = 0; i < nums.size(); ++i) {
110+
int v = nums[i];
111+
degree = max(degree, ++cnt[v]);
112+
if (!left.count(v)) {
113+
left[v] = i;
114+
}
115+
right[v] = i;
116+
}
117+
int ans = 1e6;
118+
for (int v : nums) {
119+
if (cnt[v] == degree) {
120+
int t = right[v] - left[v] + 1;
121+
if (ans > t) {
122+
ans = t;
123+
}
124+
}
125+
}
126+
return ans;
127+
}
128+
};
129+
```
130+
102131
### **Go**
103132
133+
```go
134+
func findShortestSubArray(nums []int) int {
135+
cnt := map[int]int{}
136+
left := map[int]int{}
137+
right := map[int]int{}
138+
var degree int
139+
for i, v := range nums {
140+
cnt[v]++
141+
if degree < cnt[v] {
142+
degree = cnt[v]
143+
}
144+
if _, ok := left[v]; !ok {
145+
left[v] = i
146+
}
147+
right[v] = i
148+
}
149+
ans := 100000
150+
for v, c := range cnt {
151+
if c == degree {
152+
t := right[v] - left[v] + 1
153+
if ans > t {
154+
ans = t
155+
}
156+
}
157+
}
158+
return ans
159+
}
160+
```
161+
104162
```go
105163
func findShortestSubArray(nums []int) (ans int) {
106164
ans = 50000

‎solution/0600-0699/0697.Degree of an Array/Solution.cpp

Lines changed: 27 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,27 @@
1+
class Solution {
2+
public:
3+
int findShortestSubArray(vector<int>& nums) {
4+
unordered_map<int, int> cnt;
5+
unordered_map<int, int> left;
6+
unordered_map<int, int> right;
7+
int degree = 0;
8+
for (int i = 0; i < nums.size(); ++i) {
9+
int v = nums[i];
10+
degree = max(degree, ++cnt[v]);
11+
if (!left.count(v)) {
12+
left[v] = i;
13+
}
14+
right[v] = i;
15+
}
16+
int ans = 1e6;
17+
for (int v : nums) {
18+
if (cnt[v] == degree) {
19+
int t = right[v] - left[v] + 1;
20+
if (ans > t) {
21+
ans = t;
22+
}
23+
}
24+
}
25+
return ans;
26+
}
27+
};

‎solution/0600-0699/0697.Degree of an Array/Solution.java

Lines changed: 19 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -1,27 +1,27 @@
11
class Solution {
22
public int findShortestSubArray(int[] nums) {
3-
Map<Integer, int[]> mapper = new HashMap<>();
4-
for (int i = 0, n = nums.length; i < n; ++i) {
5-
if (mapper.containsKey(nums[i])) {
6-
int[] arr = mapper.get(nums[i]);
7-
++arr[0];
8-
arr[2] = i;
9-
} else {
10-
int[] arr = new int[] {1, i, i};
11-
mapper.put(nums[i], arr);
3+
Map<Integer, Integer> cnt = new HashMap<>();
4+
Map<Integer, Integer> left = new HashMap<>();
5+
Map<Integer, Integer> right = new HashMap<>();
6+
int degree = 0;
7+
for (int i = 0; i < nums.length; ++i) {
8+
int v = nums[i];
9+
cnt.put(v, cnt.getOrDefault(v, 0) + 1);
10+
degree = Math.max(degree, cnt.get(v));
11+
if (!left.containsKey(v)) {
12+
left.put(v, i);
1213
}
14+
right.put(v, i);
1315
}
14-
15-
int maxDegree = 0, minLen = 0;
16-
for (Map.Entry<Integer, int[]> entry : mapper.entrySet()) {
17-
int[] arr = entry.getValue();
18-
if (maxDegree < arr[0]) {
19-
maxDegree = arr[0];
20-
minLen = arr[2] - arr[1] + 1;
21-
} else if (maxDegree == arr[0]) {
22-
minLen = Math.min(minLen, arr[2] - arr[1] + 1);
16+
int ans = 1000000;
17+
for (int v : nums) {
18+
if (cnt.get(v) == degree) {
19+
int t = right.get(v) - left.get(v) + 1;
20+
if (ans > t) {
21+
ans = t;
22+
}
2323
}
2424
}
25-
return minLen;
25+
return ans;
2626
}
2727
}

0 commit comments

Comments
 (0)