-
Notifications
You must be signed in to change notification settings - Fork 0
/
Degree of an Array
90 lines (82 loc) · 2.65 KB
/
Degree of an Array
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
/*
LeetCode 697:
Given a non-empty array of non-negative integers nums, the degree of this array is defined as the maximum frequency of any one of its elements.
Your task is to find the smallest possible length of a (contiguous) subarray of nums, that has the same degree as nums.
Example 1:
Input: [1, 2, 2, 3, 1]
Output: 2
Explanation:
The input array has a degree of 2 because both elements 1 and 2 appear twice.
Of the subarrays that have the same degree:
[1, 2, 2, 3, 1], [1, 2, 2, 3], [2, 2, 3, 1], [1, 2, 2], [2, 2, 3], [2, 2]
The shortest length is 2. So return 2.
Example 2:
Input: [1,2,2,3,1,4,2]
Output: 6
Note:
nums.length will be between 1 and 50,000.
nums[i] will be an integer between 0 and 49,999.
Solution:
Language: C++
Tag: hashmap
*/
class data{
public:
int start, end, count;
data(int start, int end, int count) {
this->start = start;
this->end = end;
this->count = count;
}
};
class Solution {
public:
#define min(a, b) (a < b ? a : b)
int findShortestSubArray(vector<int>& nums) {
/*
// 1. bruteforce -- O(n^2) time + O(n) space
int size = nums.size();
int max_count = 1, len = 1;
vector<bool> visited(size, false);
for (int i = 0; i < size; ++i) {
if (visited[i] == true) {
continue;
}
int count = 1, end = i;
for (int j = i + 1; j < size; ++j) {
if (nums[j] == nums[i]) {
visited[j] = true;
++count;
end = j;
}
}
if (count > max_count) {
max_count = count;
len = end - i + 1;
} else if (count == max_count) {
len = min(len, end - i + 1);
}
}
return len;
*/
// 2. hashmap: O(n) time + O(n) space
unordered_map<int, data*> hashmap;
int len = 1, max_count = 1;
for (int i = 0; i < nums.size(); ++i) {
if (hashmap.find(nums[i]) != hashmap.end()) {
hashmap[nums[i]]->end = i;
++hashmap[nums[i]]->count;
if (hashmap[nums[i]]->count > max_count) {
max_count = hashmap[nums[i]]->count;
len = hashmap[nums[i]]->end - hashmap[nums[i]]->start + 1;
} else if (hashmap[nums[i]]->count == max_count) {
len = min(len, hashmap[nums[i]]->end - hashmap[nums[i]]->start + 1);
}
} else {
data *item = new data(i, i, 1);
hashmap[nums[i]] = item;
}
}
return len;
}
};