Skip to content

Commit c4f665b

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.2524
No.2524.Maximum Frequency Score of a Subarray
1 parent b00ef57 commit c4f665b

File tree

5 files changed

+419
-6
lines changed

5 files changed

+419
-6
lines changed

‎solution/2500-2599/2524.Maximum Frequency Score of a Subarray/README.md

Lines changed: 145 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -47,6 +47,14 @@
4747

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

50+
**方法一：哈希表 + 滑动窗口 + 快速幂**
51+
52+
我们用哈希表 `cnt` 维护窗口大小为 $k$ 的元素及其出现的次数。
53+
54+
先算出初始窗口为 $k$ 的所有元素的分数。然后利用滑动窗口，每次加入一个元素，并移除最左边的元素，同时利用快速幂更新分数。
55+
56+
时间复杂度 $O(n \times \log n)$，空间复杂度 $O(n)$。其中 $n$ 是数组 `nums` 的长度。
57+
5058
<!-- tabs:start -->
5159

5260
### **Python3**
@@ -78,19 +86,153 @@ class Solution:
7886
<!-- 这里可写当前语言的特殊实现逻辑 -->
7987

8088
```java
81-
89+
class Solution {
90+
public int maxFrequencyScore(int[] nums, int k) {
91+
final int mod = (int) 1e9 + 7;
92+
Map<Integer, Integer> cnt = new HashMap<>();
93+
for (int i = 0; i < k; ++i) {
94+
cnt.put(nums[i], cnt.getOrDefault(nums[i], 0) + 1);
95+
}
96+
long cur = 0;
97+
for (var e : cnt.entrySet()) {
98+
cur = (cur + qmi(e.getKey(), e.getValue(), mod)) % mod;
99+
}
100+
long ans = cur;
101+
for (int i = k; i < nums.length; ++i) {
102+
int a = nums[i - k];
103+
int b = nums[i];
104+
if (a != b) {
105+
if (cnt.getOrDefault(b, 0) > 0) {
106+
cur += (b - 1) * qmi(b, cnt.get(b), mod) % mod;
107+
} else {
108+
cur += b;
109+
}
110+
if (cnt.getOrDefault(a, 0) > 1) {
111+
cur -= (a - 1) * qmi(a, cnt.get(a) - 1, mod) % mod;
112+
} else {
113+
cur -= a;
114+
}
115+
cur = (cur + mod) % mod;
116+
cnt.put(b, cnt.getOrDefault(b, 0) + 1);
117+
cnt.put(a, cnt.getOrDefault(a, 0) - 1);
118+
ans = Math.max(ans, cur);
119+
}
120+
}
121+
return (int) ans;
122+
}
123+
124+
long qmi(long a, long k, long p) {
125+
long res = 1;
126+
while (k != 0) {
127+
if ((k & 1) == 1) {
128+
res = res * a % p;
129+
}
130+
k >>= 1;
131+
a = a * a % p;
132+
}
133+
return res;
134+
}
135+
}
82136
```
83137

84138
### **C++**
85139

86140
```cpp
87-
141+
class Solution {
142+
public:
143+
int maxFrequencyScore(vector<int>& nums, int k) {
144+
unordered_map<int, int> cnt;
145+
for (int i = 0; i < k; ++i) {
146+
cnt[nums[i]]++;
147+
}
148+
long cur = 0;
149+
const int mod = 1e9 + 7;
150+
for (auto& [k, v] : cnt) {
151+
cur = (cur + qmi(k, v, mod)) % mod;
152+
}
153+
long ans = cur;
154+
for (int i = k; i < nums.size(); ++i) {
155+
int a = nums[i - k], b = nums[i];
156+
if (a != b) {
157+
cur += cnt[b] ? (b - 1) * qmi(b, cnt[b], mod) % mod : b;
158+
cur -= cnt[a] > 1 ? (a - 1) * qmi(a, cnt[a] - 1, mod) % mod : a;
159+
cur = (cur + mod) % mod;
160+
ans = max(ans, cur);
161+
cnt[b]++;
162+
cnt[a]--;
163+
}
164+
}
165+
return ans;
166+
}
167+
168+
long qmi(long a, long k, long p) {
169+
long res = 1;
170+
while (k != 0) {
171+
if ((k & 1) == 1) {
172+
res = res * a % p;
173+
}
174+
k >>= 1;
175+
a = a * a % p;
176+
}
177+
return res;
178+
}
179+
};
88180
```
89181

90182
### **Go**
91183

92184
```go
93-
185+
func maxFrequencyScore(nums []int, k int) int {
186+
cnt := map[int]int{}
187+
for _, v := range nums[:k] {
188+
cnt[v]++
189+
}
190+
cur := 0
191+
const mod int = 1e9 + 7
192+
for k, v := range cnt {
193+
cur = (cur + qmi(k, v, mod)) % mod
194+
}
195+
ans := cur
196+
for i := k; i < len(nums); i++ {
197+
a, b := nums[i-k], nums[i]
198+
if a != b {
199+
if cnt[b] > 0 {
200+
cur += (b - 1) * qmi(b, cnt[b], mod) % mod
201+
} else {
202+
cur += b
203+
}
204+
if cnt[a] > 1 {
205+
cur -= (a - 1) * qmi(a, cnt[a]-1, mod) % mod
206+
} else {
207+
cur -= a
208+
}
209+
cur = (cur + mod) % mod
210+
ans = max(ans, cur)
211+
cnt[b]++
212+
cnt[a]--
213+
}
214+
}
215+
return ans
216+
}
217+
218+
func max(a, b int) int {
219+
if a > b {
220+
return a
221+
}
222+
return b
223+
}
224+
225+
func qmi(a, k, p int) int {
226+
res := 1
227+
for k != 0 {
228+
if k&1 == 1 {
229+
res = res * a % p
230+
}
231+
k >>= 1
232+
a = a * a % p
233+
}
234+
return res
235+
}
94236
```
95237

96238
### **...**

‎solution/2500-2599/2524.Maximum Frequency Score of a Subarray/README_EN.md

Lines changed: 137 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -70,19 +70,153 @@ class Solution:
7070
### **Java**
7171

7272
```java
73-
73+
class Solution {
74+
public int maxFrequencyScore(int[] nums, int k) {
75+
final int mod = (int) 1e9 + 7;
76+
Map<Integer, Integer> cnt = new HashMap<>();
77+
for (int i = 0; i < k; ++i) {
78+
cnt.put(nums[i], cnt.getOrDefault(nums[i], 0) + 1);
79+
}
80+
long cur = 0;
81+
for (var e : cnt.entrySet()) {
82+
cur = (cur + qmi(e.getKey(), e.getValue(), mod)) % mod;
83+
}
84+
long ans = cur;
85+
for (int i = k; i < nums.length; ++i) {
86+
int a = nums[i - k];
87+
int b = nums[i];
88+
if (a != b) {
89+
if (cnt.getOrDefault(b, 0) > 0) {
90+
cur += (b - 1) * qmi(b, cnt.get(b), mod) % mod;
91+
} else {
92+
cur += b;
93+
}
94+
if (cnt.getOrDefault(a, 0) > 1) {
95+
cur -= (a - 1) * qmi(a, cnt.get(a) - 1, mod) % mod;
96+
} else {
97+
cur -= a;
98+
}
99+
cur = (cur + mod) % mod;
100+
cnt.put(b, cnt.getOrDefault(b, 0) + 1);
101+
cnt.put(a, cnt.getOrDefault(a, 0) - 1);
102+
ans = Math.max(ans, cur);
103+
}
104+
}
105+
return (int) ans;
106+
}
107+
108+
long qmi(long a, long k, long p) {
109+
long res = 1;
110+
while (k != 0) {
111+
if ((k & 1) == 1) {
112+
res = res * a % p;
113+
}
114+
k >>= 1;
115+
a = a * a % p;
116+
}
117+
return res;
118+
}
119+
}
74120
```
75121

76122
### **C++**
77123

78124
```cpp
79-
125+
class Solution {
126+
public:
127+
int maxFrequencyScore(vector<int>& nums, int k) {
128+
unordered_map<int, int> cnt;
129+
for (int i = 0; i < k; ++i) {
130+
cnt[nums[i]]++;
131+
}
132+
long cur = 0;
133+
const int mod = 1e9 + 7;
134+
for (auto& [k, v] : cnt) {
135+
cur = (cur + qmi(k, v, mod)) % mod;
136+
}
137+
long ans = cur;
138+
for (int i = k; i < nums.size(); ++i) {
139+
int a = nums[i - k], b = nums[i];
140+
if (a != b) {
141+
cur += cnt[b] ? (b - 1) * qmi(b, cnt[b], mod) % mod : b;
142+
cur -= cnt[a] > 1 ? (a - 1) * qmi(a, cnt[a] - 1, mod) % mod : a;
143+
cur = (cur + mod) % mod;
144+
ans = max(ans, cur);
145+
cnt[b]++;
146+
cnt[a]--;
147+
}
148+
}
149+
return ans;
150+
}
151+
152+
long qmi(long a, long k, long p) {
153+
long res = 1;
154+
while (k != 0) {
155+
if ((k & 1) == 1) {
156+
res = res * a % p;
157+
}
158+
k >>= 1;
159+
a = a * a % p;
160+
}
161+
return res;
162+
}
163+
};
80164
```
81165

82166
### **Go**
83167

84168
```go
85-
169+
func maxFrequencyScore(nums []int, k int) int {
170+
cnt := map[int]int{}
171+
for _, v := range nums[:k] {
172+
cnt[v]++
173+
}
174+
cur := 0
175+
const mod int = 1e9 + 7
176+
for k, v := range cnt {
177+
cur = (cur + qmi(k, v, mod)) % mod
178+
}
179+
ans := cur
180+
for i := k; i < len(nums); i++ {
181+
a, b := nums[i-k], nums[i]
182+
if a != b {
183+
if cnt[b] > 0 {
184+
cur += (b - 1) * qmi(b, cnt[b], mod) % mod
185+
} else {
186+
cur += b
187+
}
188+
if cnt[a] > 1 {
189+
cur -= (a - 1) * qmi(a, cnt[a]-1, mod) % mod
190+
} else {
191+
cur -= a
192+
}
193+
cur = (cur + mod) % mod
194+
ans = max(ans, cur)
195+
cnt[b]++
196+
cnt[a]--
197+
}
198+
}
199+
return ans
200+
}
201+
202+
func max(a, b int) int {
203+
if a > b {
204+
return a
205+
}
206+
return b
207+
}
208+
209+
func qmi(a, k, p int) int {
210+
res := 1
211+
for k != 0 {
212+
if k&1 == 1 {
213+
res = res * a % p
214+
}
215+
k >>= 1
216+
a = a * a % p
217+
}
218+
return res
219+
}
86220
```
87221

88222
### **...**

‎solution/2500-2599/2524.Maximum Frequency Score of a Subarray/Solution.cpp

Lines changed: 39 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,39 @@
1+
class Solution {
2+
public:
3+
int maxFrequencyScore(vector<int>& nums, int k) {
4+
unordered_map<int, int> cnt;
5+
for (int i = 0; i < k; ++i) {
6+
cnt[nums[i]]++;
7+
}
8+
long cur = 0;
9+
const int mod = 1e9 + 7;
10+
for (auto& [k, v] : cnt) {
11+
cur = (cur + qmi(k, v, mod)) % mod;
12+
}
13+
long ans = cur;
14+
for (int i = k; i < nums.size(); ++i) {
15+
int a = nums[i - k], b = nums[i];
16+
if (a != b) {
17+
cur += cnt[b] ? (b - 1) * qmi(b, cnt[b], mod) % mod : b;
18+
cur -= cnt[a] > 1 ? (a - 1) * qmi(a, cnt[a] - 1, mod) % mod : a;
19+
cur = (cur + mod) % mod;
20+
ans = max(ans, cur);
21+
cnt[b]++;
22+
cnt[a]--;
23+
}
24+
}
25+
return ans;
26+
}
27+
28+
long qmi(long a, long k, long p) {
29+
long res = 1;
30+
while (k != 0) {
31+
if ((k & 1) == 1) {
32+
res = res * a % p;
33+
}
34+
k >>= 1;
35+
a = a * a % p;
36+
}
37+
return res;
38+
}
39+
};

0 commit comments

Comments
 (0)