Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit d76ac77

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

File tree

16 files changed

+187
-275
lines changed

16 files changed

+187
-275
lines changed

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

Lines changed: 52 additions & 78 deletions
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‎

Lines changed: 52 additions & 78 deletions
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‎

Lines changed: 5 additions & 6 deletions
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)

AltStyle によって変換されたページ (->オリジナル) /