Skip to content

Commit d76ac77

Browse files
yanglbmeyanglbme
authored
feat: update solutions to lc problems: No.560,561 (doocs#2831)
1 parent 8b3999e commit d76ac77

16 files changed

+187
-275
lines changed

‎solution/0500-0599/0560.Subarray Sum Equals K/README.md

+52-78
Original file line numberDiff line numberDiff line change
@@ -54,7 +54,15 @@ tags:
5454

5555
<!-- solution:start -->
5656

57-
### 方法一
57+
### 方法一：哈希表 + 前缀和
58+
59+
我们定义一个哈希表 $\text{cnt}$，用于存储数组 $\text{nums}$ 的前缀和出现的次数。初始时，我们将 $\text{cnt}[0]$ 的值设为 $1$，表示前缀和 $0$ 出现了一次。
60+
61+
我们遍历数组 $\text{nums}$，计算前缀和 $\text{s}$，然后将 $\text{cnt}[s - k]$ 的值累加到答案中，并将 $\text{cnt}[s]$ 的值增加 $1$。
62+
63+
遍历结束后，我们返回答案。
64+
65+
时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 $\text{nums}$ 的长度。
5866

5967
<!-- tabs:start -->
6068

@@ -63,12 +71,12 @@ tags:
6371
```python
6472
class Solution:
6573
def subarraySum(self, nums: List[int], k: int) -> int:
66-
counter = Counter({0: 1})
74+
cnt = Counter({0: 1})
6775
ans = s = 0
68-
for num in nums:
69-
s += num
70-
ans += counter[s - k]
71-
counter[s] += 1
76+
for x in nums:
77+
s += x
78+
ans += cnt[s - k]
79+
cnt[s] += 1
7280
return ans
7381
```
7482

@@ -77,13 +85,13 @@ class Solution:
7785
```java
7886
class Solution {
7987
public int subarraySum(int[] nums, int k) {
80-
Map<Integer, Integer> counter = new HashMap<>();
81-
counter.put(0, 1);
88+
Map<Integer, Integer> cnt = new HashMap<>();
89+
cnt.put(0, 1);
8290
int ans = 0, s = 0;
83-
for (int num : nums) {
84-
s += num;
85-
ans += counter.getOrDefault(s - k, 0);
86-
counter.put(s, counter.getOrDefault(s, 0) + 1);
91+
for (int x : nums) {
92+
s += x;
93+
ans += cnt.getOrDefault(s - k, 0);
94+
cnt.merge(s, 1, Integer::sum);
8795
}
8896
return ans;
8997
}
@@ -96,13 +104,12 @@ class Solution {
96104
class Solution {
97105
public:
98106
int subarraySum(vector<int>& nums, int k) {
99-
unordered_map<int, int> counter;
100-
counter[0] = 1;
107+
unordered_map<int, int> cnt{{0, 1}};
101108
int ans = 0, s = 0;
102-
for (int& num : nums) {
103-
s += num;
104-
ans += counter[s - k];
105-
++counter[s];
109+
for (int x : nums) {
110+
s += x;
111+
ans += cnt[s - k];
112+
++cnt[s];
106113
}
107114
return ans;
108115
}
@@ -112,86 +119,53 @@ public:
112119
#### Go
113120
114121
```go
115-
func subarraySum(nums []int, k int) int {
116-
counter := map[int]int{0: 1}
117-
ans, s := 0, 0
118-
for _, num := range nums {
119-
s += num
120-
ans += counter[s-k]
121-
counter[s]++
122+
func subarraySum(nums []int, k int) (ans int) {
123+
cnt := map[int]int{0: 1}
124+
s := 0
125+
for _, x := range nums {
126+
s += x
127+
ans += cnt[s-k]
128+
cnt[s]++
122129
}
123-
return ans
130+
return
124131
}
125132
```
126133

127134
#### TypeScript
128135

129136
```ts
130137
function subarraySum(nums: number[], k: number): number {
131-
let ans = 0,
132-
s = 0;
133-
const counter = new Map();
134-
counter.set(0, 1);
135-
for (const num of nums) {
136-
s += num;
137-
ans += counter.get(s - k) || 0;
138-
counter.set(s, (counter.get(s) || 0) + 1);
138+
const cnt: Map<number, number> = new Map();
139+
cnt.set(0, 1);
140+
let [ans, s] = [0, 0];
141+
for (const x of nums) {
142+
s += x;
143+
ans += cnt.get(s - k) || 0;
144+
cnt.set(s, (cnt.get(s) || 0) + 1);
139145
}
140146
return ans;
141147
}
142148
```
143149

144150
#### Rust
145151

146-
```rust
147-
impl Solution {
148-
pub fn subarray_sum(mut nums: Vec<i32>, k: i32) -> i32 {
149-
let n = nums.len();
150-
let mut count = 0;
151-
for i in 0..n {
152-
let num = nums[i];
153-
if num == k {
154-
count += 1;
155-
}
156-
for j in 0..i {
157-
nums[j] += num;
158-
if nums[j] == k {
159-
count += 1;
160-
}
161-
}
162-
}
163-
count
164-
}
165-
}
166-
```
167-
168-
<!-- tabs:end -->
169-
170-
<!-- solution:end -->
171-
172-
<!-- solution:start -->
173-
174-
### 方法二
175-
176-
<!-- tabs:start -->
177-
178-
#### Rust
179-
180152
```rust
181153
use std::collections::HashMap;
182154

183155
impl Solution {
184156
pub fn subarray_sum(nums: Vec<i32>, k: i32) -> i32 {
185-
let mut res = 0;
186-
let mut sum = 0;
187-
let mut map = HashMap::new();
188-
map.insert(0, 1);
189-
nums.iter().for_each(|num| {
190-
sum += num;
191-
res += map.get(&(sum - k)).unwrap_or(&0);
192-
map.insert(sum, map.get(&sum).unwrap_or(&0) + 1);
193-
});
194-
res
157+
let mut cnt = HashMap::new();
158+
cnt.insert(0, 1);
159+
let mut ans = 0;
160+
let mut s = 0;
161+
for &x in &nums {
162+
s += x;
163+
if let Some(&v) = cnt.get(&(s - k)) {
164+
ans += v;
165+
}
166+
*cnt.entry(s).or_insert(0) += 1;
167+
}
168+
ans
195169
}
196170
}
197171
```

‎solution/0500-0599/0560.Subarray Sum Equals K/README_EN.md

+52-78
Original file line numberDiff line numberDiff line change
@@ -45,7 +45,15 @@ tags:
4545

4646
<!-- solution:start -->
4747

48-
### Solution 1
48+
### Solution 1: Hash Table + Prefix Sum
49+
50+
We define a hash table `cnt` to store the number of times the prefix sum of the array `nums` appears. Initially, we set the value of `cnt[0]` to `1`, indicating that the prefix sum `0` appears once.
51+
52+
We traverse the array `nums`, calculate the prefix sum `s`, then add the value of `cnt[s - k]` to the answer, and increase the value of `cnt[s]` by `1`.
53+
54+
After the traversal, we return the answer.
55+
56+
The time complexity is `O(n)`, and the space complexity is `O(n)`. Where `n` is the length of the array `nums`.
4957

5058
<!-- tabs:start -->
5159

@@ -54,12 +62,12 @@ tags:
5462
```python
5563
class Solution:
5664
def subarraySum(self, nums: List[int], k: int) -> int:
57-
counter = Counter({0: 1})
65+
cnt = Counter({0: 1})
5866
ans = s = 0
59-
for num in nums:
60-
s += num
61-
ans += counter[s - k]
62-
counter[s] += 1
67+
for x in nums:
68+
s += x
69+
ans += cnt[s - k]
70+
cnt[s] += 1
6371
return ans
6472
```
6573

@@ -68,13 +76,13 @@ class Solution:
6876
```java
6977
class Solution {
7078
public int subarraySum(int[] nums, int k) {
71-
Map<Integer, Integer> counter = new HashMap<>();
72-
counter.put(0, 1);
79+
Map<Integer, Integer> cnt = new HashMap<>();
80+
cnt.put(0, 1);
7381
int ans = 0, s = 0;
74-
for (int num : nums) {
75-
s += num;
76-
ans += counter.getOrDefault(s - k, 0);
77-
counter.put(s, counter.getOrDefault(s, 0) + 1);
82+
for (int x : nums) {
83+
s += x;
84+
ans += cnt.getOrDefault(s - k, 0);
85+
cnt.merge(s, 1, Integer::sum);
7886
}
7987
return ans;
8088
}
@@ -87,13 +95,12 @@ class Solution {
8795
class Solution {
8896
public:
8997
int subarraySum(vector<int>& nums, int k) {
90-
unordered_map<int, int> counter;
91-
counter[0] = 1;
98+
unordered_map<int, int> cnt{{0, 1}};
9299
int ans = 0, s = 0;
93-
for (int& num : nums) {
94-
s += num;
95-
ans += counter[s - k];
96-
++counter[s];
100+
for (int x : nums) {
101+
s += x;
102+
ans += cnt[s - k];
103+
++cnt[s];
97104
}
98105
return ans;
99106
}
@@ -103,86 +110,53 @@ public:
103110
#### Go
104111
105112
```go
106-
func subarraySum(nums []int, k int) int {
107-
counter := map[int]int{0: 1}
108-
ans, s := 0, 0
109-
for _, num := range nums {
110-
s += num
111-
ans += counter[s-k]
112-
counter[s]++
113+
func subarraySum(nums []int, k int) (ans int) {
114+
cnt := map[int]int{0: 1}
115+
s := 0
116+
for _, x := range nums {
117+
s += x
118+
ans += cnt[s-k]
119+
cnt[s]++
113120
}
114-
return ans
121+
return
115122
}
116123
```
117124

118125
#### TypeScript
119126

120127
```ts
121128
function subarraySum(nums: number[], k: number): number {
122-
let ans = 0,
123-
s = 0;
124-
const counter = new Map();
125-
counter.set(0, 1);
126-
for (const num of nums) {
127-
s += num;
128-
ans += counter.get(s - k) || 0;
129-
counter.set(s, (counter.get(s) || 0) + 1);
129+
const cnt: Map<number, number> = new Map();
130+
cnt.set(0, 1);
131+
let [ans, s] = [0, 0];
132+
for (const x of nums) {
133+
s += x;
134+
ans += cnt.get(s - k) || 0;
135+
cnt.set(s, (cnt.get(s) || 0) + 1);
130136
}
131137
return ans;
132138
}
133139
```
134140

135141
#### Rust
136142

137-
```rust
138-
impl Solution {
139-
pub fn subarray_sum(mut nums: Vec<i32>, k: i32) -> i32 {
140-
let n = nums.len();
141-
let mut count = 0;
142-
for i in 0..n {
143-
let num = nums[i];
144-
if num == k {
145-
count += 1;
146-
}
147-
for j in 0..i {
148-
nums[j] += num;
149-
if nums[j] == k {
150-
count += 1;
151-
}
152-
}
153-
}
154-
count
155-
}
156-
}
157-
```
158-
159-
<!-- tabs:end -->
160-
161-
<!-- solution:end -->
162-
163-
<!-- solution:start -->
164-
165-
### Solution 2
166-
167-
<!-- tabs:start -->
168-
169-
#### Rust
170-
171143
```rust
172144
use std::collections::HashMap;
173145

174146
impl Solution {
175147
pub fn subarray_sum(nums: Vec<i32>, k: i32) -> i32 {
176-
let mut res = 0;
177-
let mut sum = 0;
178-
let mut map = HashMap::new();
179-
map.insert(0, 1);
180-
nums.iter().for_each(|num| {
181-
sum += num;
182-
res += map.get(&(sum - k)).unwrap_or(&0);
183-
map.insert(sum, map.get(&sum).unwrap_or(&0) + 1);
184-
});
185-
res
148+
let mut cnt = HashMap::new();
149+
cnt.insert(0, 1);
150+
let mut ans = 0;
151+
let mut s = 0;
152+
for &x in &nums {
153+
s += x;
154+
if let Some(&v) = cnt.get(&(s - k)) {
155+
ans += v;
156+
}
157+
*cnt.entry(s).or_insert(0) += 1;
158+
}
159+
ans
186160
}
187161
}
188162
```

‎solution/0500-0599/0560.Subarray Sum Equals K/Solution.cpp

+5-6
Original file line numberDiff line numberDiff line change
@@ -1,13 +1,12 @@
11
class Solution {
22
public:
33
int subarraySum(vector<int>& nums, int k) {
4-
unordered_map<int, int> counter;
5-
counter[0] = 1;
4+
unordered_map<int, int> cnt{{0, 1}};
65
int ans = 0, s = 0;
7-
for (int& num : nums) {
8-
s += num;
9-
ans += counter[s - k];
10-
++counter[s];
6+
for (int x : nums) {
7+
s += x;
8+
ans += cnt[s - k];
9+
++cnt[s];
1110
}
1211
return ans;
1312
}

0 commit comments

Comments
 (0)