Skip to content

Commit e4d2641

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1224
No.1224.Maximum Equal Frequency
1 parent 0668924 commit e4d2641

File tree

7 files changed

+313
-3
lines changed

7 files changed

+313
-3
lines changed

‎solution/0200-0299/0266.Palindrome Permutation/README.md

+1-1
Original file line numberDiff line numberDiff line change
@@ -37,7 +37,7 @@
3737

3838
利用哈希表来维护元素。遍历字符串每个字母 $s[i]$，若 $s[i]$ 在哈希表中，则将 $s[i]$ 从哈希表中删除，否则将 $s[i]$ 加入哈希表。
3939

40-
遍历结束，若哈希表中元素个数不超过 $1$，则返回 true，否则返回 false。
40+
遍历结束，若哈希表中元素个数不超过 $1$，则返回 $true$，否则返回 $false$。
4141

4242
时间复杂度 $O(n)$，空间复杂度 $O(26)$。其中 $n$ 是字符串的长度。
4343

‎solution/1200-1299/1224.Maximum Equal Frequency/README.md

+115-1
Original file line numberDiff line numberDiff line change
@@ -44,22 +44,136 @@
4444

4545
<!-- 这里可写通用的实现逻辑 -->
4646

47+
**方法一：数组/哈希表**
48+
49+
用 $cnt$ 记录 $nums$ 中每个元素 $v$ 出现的次数，而 $ccnt$ 记录每个次数出现的次数，元素出现的最大次数用 $mx$ 表示。
50+
51+
遍历 $nums$：
52+
53+
- 若最大次数 $mx=1$，说明当前前缀中每个数字均出现 $1$ 次，删除任意一个后，都满足剩余数字次数相同；
54+
- 若所有数字出现的次数均为 $mx$ 和 $mx-1$，并且只有一个数字的出现次数为 $mx$，那么我们删除出现 $mx$ 次数的一个数字，剩余数字次数均为 $mx-1$，满足条件；
55+
- 若除了一个数字，其它所有数字出现次数均为 $mx$ 次，那么我们删除出现一次的数字，剩余数字次数均为 $mx$，满足条件。
56+
57+
时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 表示 $nums$ 数组的长度。
58+
4759
<!-- tabs:start -->
4860

4961
### **Python3**
5062

5163
<!-- 这里可写当前语言的特殊实现逻辑 -->
5264

5365
```python
54-
66+
class Solution:
67+
def maxEqualFreq(self, nums: List[int]) -> int:
68+
cnt = Counter()
69+
ccnt = Counter()
70+
ans = mx = 0
71+
for i, v in enumerate(nums, 1):
72+
if v in cnt:
73+
ccnt[cnt[v]] -= 1
74+
cnt[v] += 1
75+
mx = max(mx, cnt[v])
76+
ccnt[cnt[v]] += 1
77+
if mx == 1:
78+
ans = i
79+
elif ccnt[mx] * mx + ccnt[mx - 1] * (mx - 1) == i and ccnt[mx] == 1:
80+
ans = i
81+
elif ccnt[mx] * mx + 1 == i and ccnt[1] == 1:
82+
ans = i
83+
return ans
5584
```
5685

5786
### **Java**
5887

5988
<!-- 这里可写当前语言的特殊实现逻辑 -->
6089

6190
```java
91+
class Solution {
92+
private static int[] cnt = new int[100010];
93+
private static int[] ccnt = new int[100010];
94+
95+
public int maxEqualFreq(int[] nums) {
96+
Arrays.fill(cnt, 0);
97+
Arrays.fill(ccnt, 0);
98+
int ans = 0;
99+
int mx = 0;
100+
for (int i = 1; i <= nums.length; ++i) {
101+
int v = nums[i - 1];
102+
if (cnt[v] > 0) {
103+
--ccnt[cnt[v]];
104+
}
105+
++cnt[v];
106+
mx = Math.max(mx, cnt[v]);
107+
++ccnt[cnt[v]];
108+
if (mx == 1) {
109+
ans = i;
110+
} else if (ccnt[mx] * mx + ccnt[mx - 1] * (mx - 1) == i && ccnt[mx] == 1) {
111+
ans = i;
112+
} else if (ccnt[mx] * mx + 1 == i && ccnt[1] == 1) {
113+
ans = i;
114+
}
115+
}
116+
return ans;
117+
}
118+
}
119+
```
120+
121+
### **C++**
122+
123+
```cpp
124+
class Solution {
125+
public:
126+
int maxEqualFreq(vector<int>& nums) {
127+
unordered_map<int, int> cnt;
128+
unordered_map<int, int> ccnt;
129+
int ans = 0, mx = 0;
130+
for (int i = 1; i <= nums.size(); ++i) {
131+
int v = nums[i - 1];
132+
if (cnt[v]) --ccnt[cnt[v]];
133+
++cnt[v];
134+
mx = max(mx, cnt[v]);
135+
++ccnt[cnt[v]];
136+
if (mx == 1) ans = i;
137+
else if (ccnt[mx] * mx + ccnt[mx - 1] * (mx - 1) == i && ccnt[mx] == 1) ans = i;
138+
else if (ccnt[mx] * mx + 1 == i && ccnt[1] == 1) ans = i;
139+
}
140+
return ans;
141+
}
142+
};
143+
```
62144
145+
### **Go**
146+
147+
```go
148+
func maxEqualFreq(nums []int) int {
149+
cnt := map[int]int{}
150+
ccnt := map[int]int{}
151+
ans, mx := 0, 0
152+
for i, v := range nums {
153+
i++
154+
if cnt[v] > 0 {
155+
ccnt[cnt[v]]--
156+
}
157+
cnt[v]++
158+
mx = max(mx, cnt[v])
159+
ccnt[cnt[v]]++
160+
if mx == 1 {
161+
ans = i
162+
} else if ccnt[mx]*mx+ccnt[mx-1]*(mx-1) == i && ccnt[mx] == 1 {
163+
ans = i
164+
} else if ccnt[mx]*mx+1 == i && ccnt[1] == 1 {
165+
ans = i
166+
}
167+
}
168+
return ans
169+
}
170+
171+
func max(a, b int) int {
172+
if a > b {
173+
return a
174+
}
175+
return b
176+
}
63177
```
64178

65179
### **...**

‎solution/1200-1299/1224.Maximum Equal Frequency/README_EN.md

+103-1
Original file line numberDiff line numberDiff line change
@@ -39,13 +39,115 @@
3939
### **Python3**
4040

4141
```python
42-
42+
class Solution:
43+
def maxEqualFreq(self, nums: List[int]) -> int:
44+
cnt = Counter()
45+
ccnt = Counter()
46+
ans = mx = 0
47+
for i, v in enumerate(nums, 1):
48+
if v in cnt:
49+
ccnt[cnt[v]] -= 1
50+
cnt[v] += 1
51+
mx = max(mx, cnt[v])
52+
ccnt[cnt[v]] += 1
53+
if mx == 1:
54+
ans = i
55+
elif ccnt[mx] * mx + ccnt[mx - 1] * (mx - 1) == i and ccnt[mx] == 1:
56+
ans = i
57+
elif ccnt[mx] * mx + 1 == i and ccnt[1] == 1:
58+
ans = i
59+
return ans
4360
```
4461

4562
### **Java**
4663

4764
```java
65+
class Solution {
66+
private static int[] cnt = new int[100010];
67+
private static int[] ccnt = new int[100010];
68+
69+
public int maxEqualFreq(int[] nums) {
70+
Arrays.fill(cnt, 0);
71+
Arrays.fill(ccnt, 0);
72+
int ans = 0;
73+
int mx = 0;
74+
for (int i = 1; i <= nums.length; ++i) {
75+
int v = nums[i - 1];
76+
if (cnt[v] > 0) {
77+
--ccnt[cnt[v]];
78+
}
79+
++cnt[v];
80+
mx = Math.max(mx, cnt[v]);
81+
++ccnt[cnt[v]];
82+
if (mx == 1) {
83+
ans = i;
84+
} else if (ccnt[mx] * mx + ccnt[mx - 1] * (mx - 1) == i && ccnt[mx] == 1) {
85+
ans = i;
86+
} else if (ccnt[mx] * mx + 1 == i && ccnt[1] == 1) {
87+
ans = i;
88+
}
89+
}
90+
return ans;
91+
}
92+
}
93+
```
94+
95+
### **C++**
96+
97+
```cpp
98+
class Solution {
99+
public:
100+
int maxEqualFreq(vector<int>& nums) {
101+
unordered_map<int, int> cnt;
102+
unordered_map<int, int> ccnt;
103+
int ans = 0, mx = 0;
104+
for (int i = 1; i <= nums.size(); ++i) {
105+
int v = nums[i - 1];
106+
if (cnt[v]) --ccnt[cnt[v]];
107+
++cnt[v];
108+
mx = max(mx, cnt[v]);
109+
++ccnt[cnt[v]];
110+
if (mx == 1) ans = i;
111+
else if (ccnt[mx] * mx + ccnt[mx - 1] * (mx - 1) == i && ccnt[mx] == 1) ans = i;
112+
else if (ccnt[mx] * mx + 1 == i && ccnt[1] == 1) ans = i;
113+
}
114+
return ans;
115+
}
116+
};
117+
```
48118
119+
### **Go**
120+
121+
```go
122+
func maxEqualFreq(nums []int) int {
123+
cnt := map[int]int{}
124+
ccnt := map[int]int{}
125+
ans, mx := 0, 0
126+
for i, v := range nums {
127+
i++
128+
if cnt[v] > 0 {
129+
ccnt[cnt[v]]--
130+
}
131+
cnt[v]++
132+
mx = max(mx, cnt[v])
133+
ccnt[cnt[v]]++
134+
if mx == 1 {
135+
ans = i
136+
} else if ccnt[mx]*mx+ccnt[mx-1]*(mx-1) == i && ccnt[mx] == 1 {
137+
ans = i
138+
} else if ccnt[mx]*mx+1 == i && ccnt[1] == 1 {
139+
ans = i
140+
}
141+
}
142+
return ans
143+
}
144+
145+
func max(a, b int) int {
146+
if a > b {
147+
return a
148+
}
149+
return b
150+
}
49151
```
50152

51153
### **...**

‎solution/1200-1299/1224.Maximum Equal Frequency/Solution.cpp

+19
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,19 @@
1+
class Solution {
2+
public:
3+
int maxEqualFreq(vector<int>& nums) {
4+
unordered_map<int, int> cnt;
5+
unordered_map<int, int> ccnt;
6+
int ans = 0, mx = 0;
7+
for (int i = 1; i <= nums.size(); ++i) {
8+
int v = nums[i - 1];
9+
if (cnt[v]) --ccnt[cnt[v]];
10+
++cnt[v];
11+
mx = max(mx, cnt[v]);
12+
++ccnt[cnt[v]];
13+
if (mx == 1) ans = i;
14+
else if (ccnt[mx] * mx + ccnt[mx - 1] * (mx - 1) == i && ccnt[mx] == 1) ans = i;
15+
else if (ccnt[mx] * mx + 1 == i && ccnt[1] == 1) ans = i;
16+
}
17+
return ans;
18+
}
19+
};

‎solution/1200-1299/1224.Maximum Equal Frequency/Solution.go

+29
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,29 @@
1+
func maxEqualFreq(nums []int) int {
2+
cnt := map[int]int{}
3+
ccnt := map[int]int{}
4+
ans, mx := 0, 0
5+
for i, v := range nums {
6+
i++
7+
if cnt[v] > 0 {
8+
ccnt[cnt[v]]--
9+
}
10+
cnt[v]++
11+
mx = max(mx, cnt[v])
12+
ccnt[cnt[v]]++
13+
if mx == 1 {
14+
ans = i
15+
} else if ccnt[mx]*mx+ccnt[mx-1]*(mx-1) == i && ccnt[mx] == 1 {
16+
ans = i
17+
} else if ccnt[mx]*mx+1 == i && ccnt[1] == 1 {
18+
ans = i
19+
}
20+
}
21+
return ans
22+
}
23+
24+
func max(a, b int) int {
25+
if a > b {
26+
return a
27+
}
28+
return b
29+
}

‎solution/1200-1299/1224.Maximum Equal Frequency/Solution.java

+28
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
class Solution {
2+
private static int[] cnt = new int[100010];
3+
private static int[] ccnt = new int[100010];
4+
5+
public int maxEqualFreq(int[] nums) {
6+
Arrays.fill(cnt, 0);
7+
Arrays.fill(ccnt, 0);
8+
int ans = 0;
9+
int mx = 0;
10+
for (int i = 1; i <= nums.length; ++i) {
11+
int v = nums[i - 1];
12+
if (cnt[v] > 0) {
13+
--ccnt[cnt[v]];
14+
}
15+
++cnt[v];
16+
mx = Math.max(mx, cnt[v]);
17+
++ccnt[cnt[v]];
18+
if (mx == 1) {
19+
ans = i;
20+
} else if (ccnt[mx] * mx + ccnt[mx - 1] * (mx - 1) == i && ccnt[mx] == 1) {
21+
ans = i;
22+
} else if (ccnt[mx] * mx + 1 == i && ccnt[1] == 1) {
23+
ans = i;
24+
}
25+
}
26+
return ans;
27+
}
28+
}

‎solution/1200-1299/1224.Maximum Equal Frequency/Solution.py

+18
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
class Solution:
2+
def maxEqualFreq(self, nums: List[int]) -> int:
3+
cnt = Counter()
4+
ccnt = Counter()
5+
ans = mx = 0
6+
for i, v in enumerate(nums, 1):
7+
if v in cnt:
8+
ccnt[cnt[v]] -= 1
9+
cnt[v] += 1
10+
mx = max(mx, cnt[v])
11+
ccnt[cnt[v]] += 1
12+
if mx == 1:
13+
ans = i
14+
elif ccnt[mx] * mx + ccnt[mx - 1] * (mx - 1) == i and ccnt[mx] == 1:
15+
ans = i
16+
elif ccnt[mx] * mx + 1 == i and ccnt[1] == 1:
17+
ans = i
18+
return ans

0 commit comments

Comments
 (0)