Skip to content

Commit 2e8b371

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1546
No.1546.Maximum of Non-Overlapping Subarrays With Sum Equals Target
1 parent 49a38f6 commit 2e8b371

File tree

6 files changed

+261
-13
lines changed

6 files changed

+261
-13
lines changed

‎solution/1500-1599/1546.Maximum Number of Non-Overlapping Subarrays With Sum Equals Target/README.md

+95-1
Original file line numberDiff line numberDiff line change
@@ -52,22 +52,116 @@
5252

5353
<!-- 这里可写通用的实现逻辑 -->
5454

55+
贪心 + 前缀和。ans 表示结果，初始值为 0。
56+
57+
贪心：当我们发现以下标 i 结尾的子数组和为 target 时，ans++，然后继续往后查找。
58+
5559
<!-- tabs:start -->
5660

5761
### **Python3**
5862

5963
<!-- 这里可写当前语言的特殊实现逻辑 -->
6064

6165
```python
62-
66+
class Solution:
67+
def maxNonOverlapping(self, nums: List[int], target: int) -> int:
68+
i, n = 0, len(nums)
69+
ans = 0
70+
while i < n:
71+
s = 0
72+
seen = set([0])
73+
while i < n:
74+
s += nums[i]
75+
if s - target in seen:
76+
ans += 1
77+
break
78+
i += 1
79+
seen.add(s)
80+
i += 1
81+
return ans
6382
```
6483

6584
### **Java**
6685

6786
<!-- 这里可写当前语言的特殊实现逻辑 -->
6887

6988
```java
89+
class Solution {
90+
public int maxNonOverlapping(int[] nums, int target) {
91+
int i = 0, n = nums.length;
92+
int ans = 0;
93+
while (i < n) {
94+
int s = 0;
95+
Set<Integer> seen = new HashSet<>();
96+
seen.add(0);
97+
while (i < n) {
98+
s += nums[i];
99+
if (seen.contains(s - target)) {
100+
++ans;
101+
break;
102+
}
103+
++i;
104+
seen.add(s);
105+
}
106+
++i;
107+
}
108+
return ans;
109+
}
110+
}
111+
```
112+
113+
### **C++**
114+
115+
```cpp
116+
class Solution {
117+
public:
118+
int maxNonOverlapping(vector<int>& nums, int target) {
119+
int i = 0, n = nums.size();
120+
int ans = 0;
121+
while (i < n)
122+
{
123+
int s = 0;
124+
unordered_set<int> seen;
125+
seen.insert(0);
126+
while (i < n)
127+
{
128+
s += nums[i];
129+
if (seen.count(s - target))
130+
{
131+
++ans;
132+
break;
133+
}
134+
++i;
135+
seen.insert(s);
136+
}
137+
++i;
138+
}
139+
return ans;
140+
}
141+
};
142+
```
70143
144+
### **Go**
145+
146+
```go
147+
func maxNonOverlapping(nums []int, target int) int {
148+
i, n, ans := 0, len(nums), 0
149+
for i < n {
150+
s := 0
151+
seen := map[int]bool{0: true}
152+
for i < n {
153+
s += nums[i]
154+
if seen[s-target] {
155+
ans++
156+
break
157+
}
158+
seen[s] = true
159+
i++
160+
}
161+
i++
162+
}
163+
return ans
164+
}
71165
```
72166

73167
### **...**

‎solution/1500-1599/1546.Maximum Number of Non-Overlapping Subarrays With Sum Equals Target/README_EN.md

+91-1
Original file line numberDiff line numberDiff line change
@@ -55,13 +55,103 @@
5555
### **Python3**
5656

5757
```python
58-
58+
class Solution:
59+
def maxNonOverlapping(self, nums: List[int], target: int) -> int:
60+
i, n = 0, len(nums)
61+
ans = 0
62+
while i < n:
63+
s = 0
64+
seen = set([0])
65+
while i < n:
66+
s += nums[i]
67+
if s - target in seen:
68+
ans += 1
69+
break
70+
i += 1
71+
seen.add(s)
72+
i += 1
73+
return ans
5974
```
6075

6176
### **Java**
6277

6378
```java
79+
class Solution {
80+
public int maxNonOverlapping(int[] nums, int target) {
81+
int i = 0, n = nums.length;
82+
int ans = 0;
83+
while (i < n) {
84+
int s = 0;
85+
Set<Integer> seen = new HashSet<>();
86+
seen.add(0);
87+
while (i < n) {
88+
s += nums[i];
89+
if (seen.contains(s - target)) {
90+
++ans;
91+
break;
92+
}
93+
++i;
94+
seen.add(s);
95+
}
96+
++i;
97+
}
98+
return ans;
99+
}
100+
}
101+
```
102+
103+
### **C++**
104+
105+
```cpp
106+
class Solution {
107+
public:
108+
int maxNonOverlapping(vector<int>& nums, int target) {
109+
int i = 0, n = nums.size();
110+
int ans = 0;
111+
while (i < n)
112+
{
113+
int s = 0;
114+
unordered_set<int> seen;
115+
seen.insert(0);
116+
while (i < n)
117+
{
118+
s += nums[i];
119+
if (seen.count(s - target))
120+
{
121+
++ans;
122+
break;
123+
}
124+
++i;
125+
seen.insert(s);
126+
}
127+
++i;
128+
}
129+
return ans;
130+
}
131+
};
132+
```
64133
134+
### **Go**
135+
136+
```go
137+
func maxNonOverlapping(nums []int, target int) int {
138+
i, n, ans := 0, len(nums), 0
139+
for i < n {
140+
s := 0
141+
seen := map[int]bool{0: true}
142+
for i < n {
143+
s += nums[i]
144+
if seen[s-target] {
145+
ans++
146+
break
147+
}
148+
seen[s] = true
149+
i++
150+
}
151+
i++
152+
}
153+
return ans
154+
}
65155
```
66156

67157
### **...**

‎solution/1500-1599/1546.Maximum Number of Non-Overlapping Subarrays With Sum Equals Target/Solution.cpp

+26
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
class Solution {
2+
public:
3+
int maxNonOverlapping(vector<int>& nums, int target) {
4+
int i = 0, n = nums.size();
5+
int ans = 0;
6+
while (i < n)
7+
{
8+
int s = 0;
9+
unordered_set<int> seen;
10+
seen.insert(0);
11+
while (i < n)
12+
{
13+
s += nums[i];
14+
if (seen.count(s - target))
15+
{
16+
++ans;
17+
break;
18+
}
19+
++i;
20+
seen.insert(s);
21+
}
22+
++i;
23+
}
24+
return ans;
25+
}
26+
};

‎solution/1500-1599/1546.Maximum Number of Non-Overlapping Subarrays With Sum Equals Target/Solution.go

+18
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
func maxNonOverlapping(nums []int, target int) int {
2+
i, n, ans := 0, len(nums), 0
3+
for i < n {
4+
s := 0
5+
seen := map[int]bool{0: true}
6+
for i < n {
7+
s += nums[i]
8+
if seen[s-target] {
9+
ans++
10+
break
11+
}
12+
seen[s] = true
13+
i++
14+
}
15+
i++
16+
}
17+
return ans
18+
}

‎solution/1500-1599/1546.Maximum Number of Non-Overlapping Subarrays With Sum Equals Target/Solution.java

+15-11
Original file line numberDiff line numberDiff line change
@@ -1,17 +1,21 @@
11
class Solution {
22
public int maxNonOverlapping(int[] nums, int target) {
3-
Set<Integer> set = new HashSet<>();
4-
set.add(0);
5-
int sum = 0, ans = 0;
6-
for (int num : nums) {
7-
sum += num;
8-
if (set.contains(sum - target)) {
9-
ans++;
10-
set.clear();
11-
sum = 0;
3+
int i = 0, n = nums.length;
4+
int ans = 0;
5+
while (i < n) {
6+
int s = 0;
7+
Set<Integer> seen = new HashSet<>();
8+
seen.add(0);
9+
while (i < n) {
10+
s += nums[i];
11+
if (seen.contains(s - target)) {
12+
++ans;
13+
break;
14+
}
15+
++i;
16+
seen.add(s);
1217
}
13-
14-
set.add(sum);
18+
++i;
1519
}
1620
return ans;
1721
}

‎solution/1500-1599/1546.Maximum Number of Non-Overlapping Subarrays With Sum Equals Target/Solution.py

+16
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,16 @@
1+
class Solution:
2+
def maxNonOverlapping(self, nums: List[int], target: int) -> int:
3+
i, n = 0, len(nums)
4+
ans = 0
5+
while i < n:
6+
s = 0
7+
seen = set([0])
8+
while i < n:
9+
s += nums[i]
10+
if s - target in seen:
11+
ans += 1
12+
break
13+
i += 1
14+
seen.add(s)
15+
i += 1
16+
return ans

0 commit comments

Comments
 (0)