Skip to content

Commit 4b23457

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problems: No.2461,2841 (#2560)
* No.2461.Maximum Sum of Distinct Subarrays With Length K * No.2841.Maximum Sum of Almost Unique Subarray
1 parent 05495d1 commit 4b23457

File tree

13 files changed

+288
-66
lines changed

13 files changed

+288
-66
lines changed

‎solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/README.md

Lines changed: 51 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -70,11 +70,10 @@ class Solution:
7070
ans = s if len(cnt) == k else 0
7171
for i in range(k, len(nums)):
7272
cnt[nums[i]] += 1
73-
s += nums[i]
7473
cnt[nums[i - k]] -= 1
75-
s -= nums[i - k]
7674
if cnt[nums[i - k]] == 0:
77-
del cnt[nums[i - k]]
75+
cnt.pop(nums[i - k])
76+
s += nums[i] - nums[i - k]
7877
if len(cnt) == k:
7978
ans = max(ans, s)
8079
return ans
@@ -93,11 +92,10 @@ class Solution {
9392
long ans = cnt.size() == k ? s : 0;
9493
for (int i = k; i < n; ++i) {
9594
cnt.merge(nums[i], 1, Integer::sum);
96-
s += nums[i];
9795
if (cnt.merge(nums[i - k], -1, Integer::sum) == 0) {
9896
cnt.remove(nums[i - k]);
9997
}
100-
s -= nums[i - k];
98+
s += nums[i] - nums[i - k];
10199
if (cnt.size() == k) {
102100
ans = Math.max(ans, s);
103101
}
@@ -116,18 +114,16 @@ public:
116114
unordered_map<int, ll> cnt;
117115
ll s = 0;
118116
for (int i = 0; i < k; ++i) {
119-
cnt[nums[i]]++;
117+
++cnt[nums[i]];
120118
s += nums[i];
121119
}
122120
ll ans = cnt.size() == k ? s : 0;
123121
for (int i = k; i < n; ++i) {
124-
cnt[nums[i]]++;
125-
s += nums[i];
126-
cnt[nums[i - k]]--;
127-
s -= nums[i - k];
128-
if (cnt[nums[i - k]] == 0) {
122+
++cnt[nums[i]];
123+
if (--cnt[nums[i - k]] == 0) {
129124
cnt.erase(nums[i - k]);
130125
}
126+
s += nums[i] - nums[i - k];
131127
if (cnt.size() == k) {
132128
ans = max(ans, s);
133129
}
@@ -151,12 +147,11 @@ func maximumSubarraySum(nums []int, k int) (ans int64) {
151147
}
152148
for i := k; i < n; i++ {
153149
cnt[nums[i]]++
154-
s += int64(nums[i])
155150
cnt[nums[i-k]]--
156-
s -= int64(nums[i-k])
157151
if cnt[nums[i-k]] == 0 {
158152
delete(cnt, nums[i-k])
159153
}
154+
s += int64(nums[i] - nums[i-k])
160155
if len(cnt) == k && ans < s {
161156
ans = s
162157
}
@@ -177,12 +172,11 @@ function maximumSubarraySum(nums: number[], k: number): number {
177172
let ans = cnt.size === k ? s : 0;
178173
for (let i = k; i < n; ++i) {
179174
cnt.set(nums[i], (cnt.get(nums[i]) ?? 0) + 1);
180-
s += nums[i];
181175
cnt.set(nums[i - k], cnt.get(nums[i - k])! - 1);
182-
s -= nums[i - k];
183176
if (cnt.get(nums[i - k]) === 0) {
184177
cnt.delete(nums[i - k]);
185178
}
179+
s += nums[i] - nums[i - k];
186180
if (cnt.size === k) {
187181
ans = Math.max(ans, s);
188182
}
@@ -191,6 +185,48 @@ function maximumSubarraySum(nums: number[], k: number): number {
191185
}
192186
```
193187

188+
```cs
189+
public class Solution {
190+
public long MaximumSubarraySum(int[] nums, int k) {
191+
int n = nums.Length;
192+
Dictionary<int, int> cnt = new Dictionary<int, int>(k);
193+
long s = 0;
194+
195+
for (int i = 0; i < k; ++i) {
196+
if (!cnt.ContainsKey(nums[i])) {
197+
cnt[nums[i]] = 1;
198+
}
199+
else {
200+
cnt[nums[i]]++;
201+
}
202+
s += nums[i];
203+
}
204+
205+
long ans = cnt.Count == k ? s : 0;
206+
207+
for (int i = k; i < n; ++i) {
208+
if (!cnt.ContainsKey(nums[i])) {
209+
cnt[nums[i]] = 1;
210+
}
211+
else {
212+
cnt[nums[i]]++;
213+
}
214+
if (--cnt[nums[i - k]] == 0) {
215+
cnt.Remove(nums[i - k]);
216+
}
217+
218+
s += nums[i] - nums[i - k];
219+
220+
if (cnt.Count == k) {
221+
ans = Math.Max(ans, s);
222+
}
223+
}
224+
225+
return ans;
226+
}
227+
}
228+
```
229+
194230
<!-- tabs:end -->
195231

196232
<!-- end -->

‎solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/README_EN.md

Lines changed: 51 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -68,11 +68,10 @@ class Solution:
6868
ans = s if len(cnt) == k else 0
6969
for i in range(k, len(nums)):
7070
cnt[nums[i]] += 1
71-
s += nums[i]
7271
cnt[nums[i - k]] -= 1
73-
s -= nums[i - k]
7472
if cnt[nums[i - k]] == 0:
75-
del cnt[nums[i - k]]
73+
cnt.pop(nums[i - k])
74+
s += nums[i] - nums[i - k]
7675
if len(cnt) == k:
7776
ans = max(ans, s)
7877
return ans
@@ -91,11 +90,10 @@ class Solution {
9190
long ans = cnt.size() == k ? s : 0;
9291
for (int i = k; i < n; ++i) {
9392
cnt.merge(nums[i], 1, Integer::sum);
94-
s += nums[i];
9593
if (cnt.merge(nums[i - k], -1, Integer::sum) == 0) {
9694
cnt.remove(nums[i - k]);
9795
}
98-
s -= nums[i - k];
96+
s += nums[i] - nums[i - k];
9997
if (cnt.size() == k) {
10098
ans = Math.max(ans, s);
10199
}
@@ -114,18 +112,16 @@ public:
114112
unordered_map<int, ll> cnt;
115113
ll s = 0;
116114
for (int i = 0; i < k; ++i) {
117-
cnt[nums[i]]++;
115+
++cnt[nums[i]];
118116
s += nums[i];
119117
}
120118
ll ans = cnt.size() == k ? s : 0;
121119
for (int i = k; i < n; ++i) {
122-
cnt[nums[i]]++;
123-
s += nums[i];
124-
cnt[nums[i - k]]--;
125-
s -= nums[i - k];
126-
if (cnt[nums[i - k]] == 0) {
120+
++cnt[nums[i]];
121+
if (--cnt[nums[i - k]] == 0) {
127122
cnt.erase(nums[i - k]);
128123
}
124+
s += nums[i] - nums[i - k];
129125
if (cnt.size() == k) {
130126
ans = max(ans, s);
131127
}
@@ -149,12 +145,11 @@ func maximumSubarraySum(nums []int, k int) (ans int64) {
149145
}
150146
for i := k; i < n; i++ {
151147
cnt[nums[i]]++
152-
s += int64(nums[i])
153148
cnt[nums[i-k]]--
154-
s -= int64(nums[i-k])
155149
if cnt[nums[i-k]] == 0 {
156150
delete(cnt, nums[i-k])
157151
}
152+
s += int64(nums[i] - nums[i-k])
158153
if len(cnt) == k && ans < s {
159154
ans = s
160155
}
@@ -175,12 +170,11 @@ function maximumSubarraySum(nums: number[], k: number): number {
175170
let ans = cnt.size === k ? s : 0;
176171
for (let i = k; i < n; ++i) {
177172
cnt.set(nums[i], (cnt.get(nums[i]) ?? 0) + 1);
178-
s += nums[i];
179173
cnt.set(nums[i - k], cnt.get(nums[i - k])! - 1);
180-
s -= nums[i - k];
181174
if (cnt.get(nums[i - k]) === 0) {
182175
cnt.delete(nums[i - k]);
183176
}
177+
s += nums[i] - nums[i - k];
184178
if (cnt.size === k) {
185179
ans = Math.max(ans, s);
186180
}
@@ -189,6 +183,48 @@ function maximumSubarraySum(nums: number[], k: number): number {
189183
}
190184
```
191185

186+
```cs
187+
public class Solution {
188+
public long MaximumSubarraySum(int[] nums, int k) {
189+
int n = nums.Length;
190+
Dictionary<int, int> cnt = new Dictionary<int, int>(k);
191+
long s = 0;
192+
193+
for (int i = 0; i < k; ++i) {
194+
if (!cnt.ContainsKey(nums[i])) {
195+
cnt[nums[i]] = 1;
196+
}
197+
else {
198+
cnt[nums[i]]++;
199+
}
200+
s += nums[i];
201+
}
202+
203+
long ans = cnt.Count == k ? s : 0;
204+
205+
for (int i = k; i < n; ++i) {
206+
if (!cnt.ContainsKey(nums[i])) {
207+
cnt[nums[i]] = 1;
208+
}
209+
else {
210+
cnt[nums[i]]++;
211+
}
212+
if (--cnt[nums[i - k]] == 0) {
213+
cnt.Remove(nums[i - k]);
214+
}
215+
216+
s += nums[i] - nums[i - k];
217+
218+
if (cnt.Count == k) {
219+
ans = Math.Max(ans, s);
220+
}
221+
}
222+
223+
return ans;
224+
}
225+
}
226+
```
227+
192228
<!-- tabs:end -->
193229

194230
<!-- end -->

‎solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/Solution.cpp

Lines changed: 4 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -6,18 +6,16 @@ class Solution {
66
unordered_map<int, ll> cnt;
77
ll s = 0;
88
for (int i = 0; i < k; ++i) {
9-
cnt[nums[i]]++;
9+
++cnt[nums[i]];
1010
s += nums[i];
1111
}
1212
ll ans = cnt.size() == k ? s : 0;
1313
for (int i = k; i < n; ++i) {
14-
cnt[nums[i]]++;
15-
s += nums[i];
16-
cnt[nums[i - k]]--;
17-
s -= nums[i - k];
18-
if (cnt[nums[i - k]] == 0) {
14+
++cnt[nums[i]];
15+
if (--cnt[nums[i - k]] == 0) {
1916
cnt.erase(nums[i - k]);
2017
}
18+
s += nums[i] - nums[i - k];
2119
if (cnt.size() == k) {
2220
ans = max(ans, s);
2321
}

‎solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/Solution.cs

Lines changed: 39 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,39 @@
1+
public class Solution {
2+
public long MaximumSubarraySum(int[] nums, int k) {
3+
int n = nums.Length;
4+
Dictionary<int, int> cnt = new Dictionary<int, int>(k);
5+
long s = 0;
6+
7+
for (int i = 0; i < k; ++i) {
8+
if (!cnt.ContainsKey(nums[i])) {
9+
cnt[nums[i]] = 1;
10+
}
11+
else {
12+
cnt[nums[i]]++;
13+
}
14+
s += nums[i];
15+
}
16+
17+
long ans = cnt.Count == k ? s : 0;
18+
19+
for (int i = k; i < n; ++i) {
20+
if (!cnt.ContainsKey(nums[i])) {
21+
cnt[nums[i]] = 1;
22+
}
23+
else {
24+
cnt[nums[i]]++;
25+
}
26+
if (--cnt[nums[i - k]] == 0) {
27+
cnt.Remove(nums[i - k]);
28+
}
29+
30+
s += nums[i] - nums[i - k];
31+
32+
if (cnt.Count == k) {
33+
ans = Math.Max(ans, s);
34+
}
35+
}
36+
37+
return ans;
38+
}
39+
}

‎solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/Solution.go

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -11,12 +11,11 @@ func maximumSubarraySum(nums []int, k int) (ans int64) {
1111
}
1212
for i := k; i < n; i++ {
1313
cnt[nums[i]]++
14-
s += int64(nums[i])
1514
cnt[nums[i-k]]--
16-
s -= int64(nums[i-k])
1715
if cnt[nums[i-k]] == 0 {
1816
delete(cnt, nums[i-k])
1917
}
18+
s += int64(nums[i] - nums[i-k])
2019
if len(cnt) == k && ans < s {
2120
ans = s
2221
}

‎solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/Solution.java

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -10,11 +10,10 @@ public long maximumSubarraySum(int[] nums, int k) {
1010
long ans = cnt.size() == k ? s : 0;
1111
for (int i = k; i < n; ++i) {
1212
cnt.merge(nums[i], 1, Integer::sum);
13-
s += nums[i];
1413
if (cnt.merge(nums[i - k], -1, Integer::sum) == 0) {
1514
cnt.remove(nums[i - k]);
1615
}
17-
s -= nums[i - k];
16+
s += nums[i] - nums[i - k];
1817
if (cnt.size() == k) {
1918
ans = Math.max(ans, s);
2019
}

‎solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/Solution.py

Lines changed: 2 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -5,11 +5,10 @@ def maximumSubarraySum(self, nums: List[int], k: int) -> int:
55
ans = s if len(cnt) == k else 0
66
for i in range(k, len(nums)):
77
cnt[nums[i]] += 1
8-
s += nums[i]
98
cnt[nums[i - k]] -= 1
10-
s -= nums[i - k]
119
if cnt[nums[i - k]] == 0:
12-
del cnt[nums[i - k]]
10+
cnt.pop(nums[i - k])
11+
s += nums[i] - nums[i - k]
1312
if len(cnt) == k:
1413
ans = max(ans, s)
1514
return ans

‎solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/Solution.ts

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -9,12 +9,11 @@ function maximumSubarraySum(nums: number[], k: number): number {
99
let ans = cnt.size === k ? s : 0;
1010
for (let i = k; i < n; ++i) {
1111
cnt.set(nums[i], (cnt.get(nums[i]) ?? 0) + 1);
12-
s += nums[i];
1312
cnt.set(nums[i - k], cnt.get(nums[i - k])! - 1);
14-
s -= nums[i - k];
1513
if (cnt.get(nums[i - k]) === 0) {
1614
cnt.delete(nums[i - k]);
1715
}
16+
s += nums[i] - nums[i - k];
1817
if (cnt.size === k) {
1918
ans = Math.max(ans, s);
2019
}

0 commit comments

Comments
 (0)