Skip to content

Commit 5203608

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.2461
No.2461.Maximum Sum of Distinct Subarrays With Length K
1 parent 4c74b4d commit 5203608

File tree

7 files changed

+191
-151
lines changed

7 files changed

+191
-151
lines changed

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

Lines changed: 66 additions & 53 deletions
Original file line numberDiff line numberDiff line change
@@ -54,11 +54,11 @@
5454

5555
<!-- 这里可写通用的实现逻辑 -->
5656

57-
**方法一：滑动窗口**
57+
**方法一：滑动窗口 + 哈希表**
5858

59-
我们维护一个长度为 $k$ 的滑动窗口，用哈希表 `cnt` 记录窗口中每个数字出现的次数，用 变量 $s$ 记录窗口中所有数字的和。每次滑动窗口，如果窗口中的数字都不重复，那么更新答案。
59+
我们维护一个长度为 $k$ 的滑动窗口，用哈希表 $cnt$ 记录窗口中每个数字出现的次数，用变量 $s$ 记录窗口中所有数字的和。每次滑动窗口，如果窗口中的数字都不重复，那么更新答案。
6060

61-
时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 `nums` 的长度。
61+
时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 $nums$ 的长度。
6262

6363
<!-- tabs:start -->
6464

@@ -69,21 +69,18 @@
6969
```python
7070
class Solution:
7171
def maximumSubarraySum(self, nums: List[int], k: int) -> int:
72-
n = len(nums)
7372
cnt = Counter(nums[:k])
7473
s = sum(nums[:k])
75-
ans = 0
76-
for i in range(k, n):
77-
if len(cnt) == k:
78-
ans = max(ans, s)
74+
ans = s if len(cnt) == k else 0
75+
for i in range(k, len(nums)):
7976
cnt[nums[i]] += 1
80-
cnt[nums[i - k]] -= 1
8177
s += nums[i]
78+
cnt[nums[i - k]] -= 1
8279
s -= nums[i - k]
8380
if cnt[nums[i - k]] == 0:
84-
cnt.pop(nums[i - k])
85-
if len(cnt) == k:
86-
ans = max(ans, s)
81+
del cnt[nums[i - k]]
82+
if len(cnt) == k:
83+
ans = max(ans, s)
8784
return ans
8885
```
8986

@@ -98,24 +95,20 @@ class Solution {
9895
Map<Integer, Integer> cnt = new HashMap<>(k);
9996
long s = 0;
10097
for (int i = 0; i < k; ++i) {
101-
cnt.put(nums[i], cnt.getOrDefault(nums[i], 0) + 1);
98+
cnt.merge(nums[i], 1, Integer::sum);
10299
s += nums[i];
103100
}
104-
long ans = 0;
101+
long ans = cnt.size() == k ? s : 0;
105102
for (int i = k; i < n; ++i) {
106-
if (cnt.size() == k) {
107-
ans = Math.max(ans, s);
108-
}
109-
cnt.put(nums[i], cnt.getOrDefault(nums[i], 0) + 1);
110-
cnt.put(nums[i - k], cnt.getOrDefault(nums[i - k], 0) - 1);
111-
if (cnt.get(nums[i - k]) == 0) {
103+
cnt.merge(nums[i], 1, Integer::sum);
104+
s += nums[i];
105+
if (cnt.merge(nums[i - k], -1, Integer::sum) == 0) {
112106
cnt.remove(nums[i - k]);
113107
}
114-
s += nums[i];
115108
s -= nums[i - k];
116-
}
117-
if (cnt.size() == k) {
118-
ans = Math.max(ans, s);
109+
if (cnt.size() == k) {
110+
ans = Math.max(ans, s);
111+
}
119112
}
120113
return ans;
121114
}
@@ -128,22 +121,27 @@ class Solution {
128121
class Solution {
129122
public:
130123
long long maximumSubarraySum(vector<int>& nums, int k) {
124+
using ll = long long;
131125
int n = nums.size();
132-
unordered_map<int, int> cnt;
133-
long long s = 0, ans = 0;
126+
unordered_map<int, ll> cnt;
127+
ll s = 0;
134128
for (int i = 0; i < k; ++i) {
135129
cnt[nums[i]]++;
136130
s += nums[i];
137131
}
132+
ll ans = cnt.size() == k ? s : 0;
138133
for (int i = k; i < n; ++i) {
139-
if (cnt.size() == k) ans = max(ans, s);
140134
cnt[nums[i]]++;
141-
cnt[nums[i - k]]--;
142-
if (cnt[nums[i - k]] == 0) cnt.erase(nums[i - k]);
143135
s += nums[i];
136+
cnt[nums[i - k]]--;
144137
s -= nums[i - k];
138+
if (cnt[nums[i - k]] == 0) {
139+
cnt.erase(nums[i - k]);
140+
}
141+
if (cnt.size() == k) {
142+
ans = max(ans, s);
143+
}
145144
}
146-
if (cnt.size() == k) ans = max(ans, s);
147145
return ans;
148146
}
149147
};
@@ -152,44 +150,59 @@ public:
152150
### **Go**
153151
154152
```go
155-
func maximumSubarraySum(nums []int, k int) int64 {
153+
func maximumSubarraySum(nums []int, k int) (ans int64) {
156154
n := len(nums)
157-
cnt := map[int]int{}
158-
s, ans := 0, 0
159-
for i := 0; i < k; i++ {
160-
cnt[nums[i]]++
161-
s += nums[i]
155+
cnt := map[int]int64{}
156+
var s int64
157+
for _, x := range nums[:k] {
158+
cnt[x]++
159+
s += int64(x)
160+
}
161+
if len(cnt) == k {
162+
ans = s
162163
}
163164
for i := k; i < n; i++ {
164-
if len(cnt) == k {
165-
ans = max(ans, s)
166-
}
167165
cnt[nums[i]]++
166+
s += int64(nums[i])
168167
cnt[nums[i-k]]--
168+
s -= int64(nums[i-k])
169169
if cnt[nums[i-k]] == 0 {
170170
delete(cnt, nums[i-k])
171171
}
172-
s += nums[i]
173-
s -= nums[i-k]
174-
}
175-
if len(cnt) == k {
176-
ans = max(ans, s)
177-
}
178-
return int64(ans)
179-
}
180-
181-
func max(a, b int) int {
182-
if a > b {
183-
return a
172+
if len(cnt) == k && ans < s {
173+
ans = s
174+
}
184175
}
185-
return b
176+
return
186177
}
187178
```
188179

189180
### **TypeScript**
190181

191182
```ts
192-
183+
function maximumSubarraySum(nums: number[], k: number): number {
184+
const n = nums.length;
185+
const cnt: Map<number, number> = new Map();
186+
let s = 0;
187+
for (let i = 0; i < k; ++i) {
188+
cnt.set(nums[i], (cnt.get(nums[i]) ?? 0) + 1);
189+
s += nums[i];
190+
}
191+
let ans = cnt.size === k ? s : 0;
192+
for (let i = k; i < n; ++i) {
193+
cnt.set(nums[i], (cnt.get(nums[i]) ?? 0) + 1);
194+
s += nums[i];
195+
cnt.set(nums[i - k], cnt.get(nums[i - k])! - 1);
196+
s -= nums[i - k];
197+
if (cnt.get(nums[i - k]) === 0) {
198+
cnt.delete(nums[i - k]);
199+
}
200+
if (cnt.size === k) {
201+
ans = Math.max(ans, s);
202+
}
203+
}
204+
return ans;
205+
}
193206
```
194207

195208
### **...**

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

Lines changed: 63 additions & 50 deletions
Original file line numberDiff line numberDiff line change
@@ -57,21 +57,18 @@ We return 0 because no subarrays meet the conditions.
5757
```python
5858
class Solution:
5959
def maximumSubarraySum(self, nums: List[int], k: int) -> int:
60-
n = len(nums)
6160
cnt = Counter(nums[:k])
6261
s = sum(nums[:k])
63-
ans = 0
64-
for i in range(k, n):
65-
if len(cnt) == k:
66-
ans = max(ans, s)
62+
ans = s if len(cnt) == k else 0
63+
for i in range(k, len(nums)):
6764
cnt[nums[i]] += 1
68-
cnt[nums[i - k]] -= 1
6965
s += nums[i]
66+
cnt[nums[i - k]] -= 1
7067
s -= nums[i - k]
7168
if cnt[nums[i - k]] == 0:
72-
cnt.pop(nums[i - k])
73-
if len(cnt) == k:
74-
ans = max(ans, s)
69+
del cnt[nums[i - k]]
70+
if len(cnt) == k:
71+
ans = max(ans, s)
7572
return ans
7673
```
7774

@@ -84,24 +81,20 @@ class Solution {
8481
Map<Integer, Integer> cnt = new HashMap<>(k);
8582
long s = 0;
8683
for (int i = 0; i < k; ++i) {
87-
cnt.put(nums[i], cnt.getOrDefault(nums[i], 0) + 1);
84+
cnt.merge(nums[i], 1, Integer::sum);
8885
s += nums[i];
8986
}
90-
long ans = 0;
87+
long ans = cnt.size() == k ? s : 0;
9188
for (int i = k; i < n; ++i) {
92-
if (cnt.size() == k) {
93-
ans = Math.max(ans, s);
94-
}
95-
cnt.put(nums[i], cnt.getOrDefault(nums[i], 0) + 1);
96-
cnt.put(nums[i - k], cnt.getOrDefault(nums[i - k], 0) - 1);
97-
if (cnt.get(nums[i - k]) == 0) {
89+
cnt.merge(nums[i], 1, Integer::sum);
90+
s += nums[i];
91+
if (cnt.merge(nums[i - k], -1, Integer::sum) == 0) {
9892
cnt.remove(nums[i - k]);
9993
}
100-
s += nums[i];
10194
s -= nums[i - k];
102-
}
103-
if (cnt.size() == k) {
104-
ans = Math.max(ans, s);
95+
if (cnt.size() == k) {
96+
ans = Math.max(ans, s);
97+
}
10598
}
10699
return ans;
107100
}
@@ -114,22 +107,27 @@ class Solution {
114107
class Solution {
115108
public:
116109
long long maximumSubarraySum(vector<int>& nums, int k) {
110+
using ll = long long;
117111
int n = nums.size();
118-
unordered_map<int, int> cnt;
119-
long long s = 0, ans = 0;
112+
unordered_map<int, ll> cnt;
113+
ll s = 0;
120114
for (int i = 0; i < k; ++i) {
121115
cnt[nums[i]]++;
122116
s += nums[i];
123117
}
118+
ll ans = cnt.size() == k ? s : 0;
124119
for (int i = k; i < n; ++i) {
125-
if (cnt.size() == k) ans = max(ans, s);
126120
cnt[nums[i]]++;
127-
cnt[nums[i - k]]--;
128-
if (cnt[nums[i - k]] == 0) cnt.erase(nums[i - k]);
129121
s += nums[i];
122+
cnt[nums[i - k]]--;
130123
s -= nums[i - k];
124+
if (cnt[nums[i - k]] == 0) {
125+
cnt.erase(nums[i - k]);
126+
}
127+
if (cnt.size() == k) {
128+
ans = max(ans, s);
129+
}
131130
}
132-
if (cnt.size() == k) ans = max(ans, s);
133131
return ans;
134132
}
135133
};
@@ -138,44 +136,59 @@ public:
138136
### **Go**
139137
140138
```go
141-
func maximumSubarraySum(nums []int, k int) int64 {
139+
func maximumSubarraySum(nums []int, k int) (ans int64) {
142140
n := len(nums)
143-
cnt := map[int]int{}
144-
s, ans := 0, 0
145-
for i := 0; i < k; i++ {
146-
cnt[nums[i]]++
147-
s += nums[i]
141+
cnt := map[int]int64{}
142+
var s int64
143+
for _, x := range nums[:k] {
144+
cnt[x]++
145+
s += int64(x)
146+
}
147+
if len(cnt) == k {
148+
ans = s
148149
}
149150
for i := k; i < n; i++ {
150-
if len(cnt) == k {
151-
ans = max(ans, s)
152-
}
153151
cnt[nums[i]]++
152+
s += int64(nums[i])
154153
cnt[nums[i-k]]--
154+
s -= int64(nums[i-k])
155155
if cnt[nums[i-k]] == 0 {
156156
delete(cnt, nums[i-k])
157157
}
158-
s += nums[i]
159-
s -= nums[i-k]
160-
}
161-
if len(cnt) == k {
162-
ans = max(ans, s)
163-
}
164-
return int64(ans)
165-
}
166-
167-
func max(a, b int) int {
168-
if a > b {
169-
return a
158+
if len(cnt) == k && ans < s {
159+
ans = s
160+
}
170161
}
171-
return b
162+
return
172163
}
173164
```
174165

175166
### **TypeScript**
176167

177168
```ts
178-
169+
function maximumSubarraySum(nums: number[], k: number): number {
170+
const n = nums.length;
171+
const cnt: Map<number, number> = new Map();
172+
let s = 0;
173+
for (let i = 0; i < k; ++i) {
174+
cnt.set(nums[i], (cnt.get(nums[i]) ?? 0) + 1);
175+
s += nums[i];
176+
}
177+
let ans = cnt.size === k ? s : 0;
178+
for (let i = k; i < n; ++i) {
179+
cnt.set(nums[i], (cnt.get(nums[i]) ?? 0) + 1);
180+
s += nums[i];
181+
cnt.set(nums[i - k], cnt.get(nums[i - k])! - 1);
182+
s -= nums[i - k];
183+
if (cnt.get(nums[i - k]) === 0) {
184+
cnt.delete(nums[i - k]);
185+
}
186+
if (cnt.size === k) {
187+
ans = Math.max(ans, s);
188+
}
189+
}
190+
return ans;
191+
}
179192
```
180193

181194
### **...**

0 commit comments

Comments
 (0)