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 368c441

Browse files
feat: add solutions to lc problems: No.1546,1547,1551 (#2072)
* No.1546.Maximum Number of Non-Overlapping Subarrays With Sum Equals Target * No.1547.Minimum Cost to Cut a Stick * No.1551.Minimum Operations to Make Array Equal
1 parent 14db2a5 commit 368c441

File tree

9 files changed

+216
-131
lines changed

9 files changed

+216
-131
lines changed

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

Lines changed: 50 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -52,9 +52,11 @@
5252

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

55-
贪心 + 前缀和。ans 表示结果,初始值为 0。
55+
**方法一:贪心 + 前缀和 + 哈希表**
5656

57-
贪心:当我们发现以下标 i 结尾的子数组和为 target 时,ans++,然后继续往后查找。
57+
我们遍历数组 $nums,ドル利用前缀和 + 哈希表的方法,寻找和为 $target$ 的子数组,若找到,则答案加一,然后我们将前缀和置为 0ドル,ドル继续遍历数组 $nums,ドル直到遍历完整个数组。
58+
59+
时间复杂度 $O(n),ドル空间复杂度 $O(n)$。其中 $n$ 为数组 $nums$ 的长度。
5860

5961
<!-- tabs:start -->
6062

@@ -65,18 +67,18 @@
6567
```python
6668
class Solution:
6769
def maxNonOverlapping(self, nums: List[int], target: int) -> int:
68-
i, n = 0, len(nums)
6970
ans = 0
71+
i, n = 0, len(nums)
7072
while i < n:
7173
s = 0
72-
seen = {0}
74+
vis = {0}
7375
while i < n:
7476
s += nums[i]
75-
if s - target in seen:
77+
if s - target in vis:
7678
ans += 1
7779
break
7880
i += 1
79-
seen.add(s)
81+
vis.add(s)
8082
i += 1
8183
return ans
8284
```
@@ -88,22 +90,20 @@ class Solution:
8890
```java
8991
class Solution {
9092
public int maxNonOverlapping(int[] nums, int target) {
91-
int i = 0, n = nums.length;
92-
int ans = 0;
93-
while (i < n) {
93+
int ans = 0, n = nums.length;
94+
for (int i = 0; i < n; ++i) {
95+
Set<Integer> vis =newHashSet<>();
9496
int s = 0;
95-
Set<Integer> seen = new HashSet<>();
96-
seen.add(0);
97+
vis.add(0);
9798
while (i < n) {
9899
s += nums[i];
99-
if (seen.contains(s - target)) {
100+
if (vis.contains(s - target)) {
100101
++ans;
101102
break;
102103
}
103104
++i;
104-
seen.add(s);
105+
vis.add(s);
105106
}
106-
++i;
107107
}
108108
return ans;
109109
}
@@ -116,22 +116,19 @@ class Solution {
116116
class Solution {
117117
public:
118118
int maxNonOverlapping(vector<int>& nums, int target) {
119-
int i = 0, n = nums.size();
120-
int ans = 0;
121-
while (i < n) {
119+
int ans = 0, n = nums.size();
120+
for (int i = 0; i < n; ++i) {
121+
unordered_set<int> vis{{0}};
122122
int s = 0;
123-
unordered_set<int> seen;
124-
seen.insert(0);
125123
while (i < n) {
126124
s += nums[i];
127-
if (seen.count(s - target)) {
125+
if (vis.count(s - target)) {
128126
++ans;
129127
break;
130128
}
131129
++i;
132-
seen.insert(s);
130+
vis.insert(s);
133131
}
134-
++i;
135132
}
136133
return ans;
137134
}
@@ -141,23 +138,44 @@ public:
141138
### **Go**
142139
143140
```go
144-
func maxNonOverlapping(nums []int, target int) int {
145-
i, n, ans := 0, len(nums), 0
146-
for i < n {
141+
func maxNonOverlapping(nums []int, target int) (ans int) {
142+
n := len(nums)
143+
for i := 0; i < n; i++ {
147144
s := 0
148-
seen := map[int]bool{0: true}
149-
for i < n {
145+
vis := map[int]bool{0: true}
146+
for ; i < n; i++ {
150147
s += nums[i]
151-
if seen[s-target] {
148+
if vis[s-target] {
152149
ans++
153150
break
154151
}
155-
seen[s] = true
156-
i++
152+
vis[s] = true
157153
}
158-
i++
159154
}
160-
return ans
155+
return
156+
}
157+
```
158+
159+
### **TypeScript**
160+
161+
```ts
162+
function maxNonOverlapping(nums: number[], target: number): number {
163+
const n = nums.length;
164+
let ans = 0;
165+
for (let i = 0; i < n; ++i) {
166+
let s = 0;
167+
const vis: Set<number> = new Set();
168+
vis.add(0);
169+
for (; i < n; ++i) {
170+
s += nums[i];
171+
if (vis.has(s - target)) {
172+
++ans;
173+
break;
174+
}
175+
vis.add(s);
176+
}
177+
}
178+
return ans;
161179
}
162180
```
163181

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

Lines changed: 52 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -35,25 +35,31 @@
3535

3636
## Solutions
3737

38+
**Solution 1: Greedy + Prefix Sum + Hash Table**
39+
40+
We traverse the array $nums,ドル using the method of prefix sum + hash table, to find subarrays with a sum of $target$. If found, we increment the answer by one, then we set the prefix sum to 0ドル$ and continue to traverse the array $nums$ until the entire array is traversed.
41+
42+
The time complexity is $O(n),ドル and the space complexity is $O(n)$. Here, $n$ is the length of the array $nums$.
43+
3844
<!-- tabs:start -->
3945

4046
### **Python3**
4147

4248
```python
4349
class Solution:
4450
def maxNonOverlapping(self, nums: List[int], target: int) -> int:
45-
i, n = 0, len(nums)
4651
ans = 0
52+
i, n = 0, len(nums)
4753
while i < n:
4854
s = 0
49-
seen = {0}
55+
vis = {0}
5056
while i < n:
5157
s += nums[i]
52-
if s - target in seen:
58+
if s - target in vis:
5359
ans += 1
5460
break
5561
i += 1
56-
seen.add(s)
62+
vis.add(s)
5763
i += 1
5864
return ans
5965
```
@@ -63,22 +69,20 @@ class Solution:
6369
```java
6470
class Solution {
6571
public int maxNonOverlapping(int[] nums, int target) {
66-
int i = 0, n = nums.length;
67-
int ans = 0;
68-
while (i < n) {
72+
int ans = 0, n = nums.length;
73+
for (int i = 0; i < n; ++i) {
74+
Set<Integer> vis =newHashSet<>();
6975
int s = 0;
70-
Set<Integer> seen = new HashSet<>();
71-
seen.add(0);
76+
vis.add(0);
7277
while (i < n) {
7378
s += nums[i];
74-
if (seen.contains(s - target)) {
79+
if (vis.contains(s - target)) {
7580
++ans;
7681
break;
7782
}
7883
++i;
79-
seen.add(s);
84+
vis.add(s);
8085
}
81-
++i;
8286
}
8387
return ans;
8488
}
@@ -91,22 +95,19 @@ class Solution {
9195
class Solution {
9296
public:
9397
int maxNonOverlapping(vector<int>& nums, int target) {
94-
int i = 0, n = nums.size();
95-
int ans = 0;
96-
while (i < n) {
98+
int ans = 0, n = nums.size();
99+
for (int i = 0; i < n; ++i) {
100+
unordered_set<int> vis{{0}};
97101
int s = 0;
98-
unordered_set<int> seen;
99-
seen.insert(0);
100102
while (i < n) {
101103
s += nums[i];
102-
if (seen.count(s - target)) {
104+
if (vis.count(s - target)) {
103105
++ans;
104106
break;
105107
}
106108
++i;
107-
seen.insert(s);
109+
vis.insert(s);
108110
}
109-
++i;
110111
}
111112
return ans;
112113
}
@@ -116,23 +117,44 @@ public:
116117
### **Go**
117118
118119
```go
119-
func maxNonOverlapping(nums []int, target int) int {
120-
i, n, ans := 0, len(nums), 0
121-
for i < n {
120+
func maxNonOverlapping(nums []int, target int) (ans int) {
121+
n := len(nums)
122+
for i := 0; i < n; i++ {
122123
s := 0
123-
seen := map[int]bool{0: true}
124-
for i < n {
124+
vis := map[int]bool{0: true}
125+
for ; i < n; i++ {
125126
s += nums[i]
126-
if seen[s-target] {
127+
if vis[s-target] {
127128
ans++
128129
break
129130
}
130-
seen[s] = true
131-
i++
131+
vis[s] = true
132132
}
133-
i++
134133
}
135-
return ans
134+
return
135+
}
136+
```
137+
138+
### **TypeScript**
139+
140+
```ts
141+
function maxNonOverlapping(nums: number[], target: number): number {
142+
const n = nums.length;
143+
let ans = 0;
144+
for (let i = 0; i < n; ++i) {
145+
let s = 0;
146+
const vis: Set<number> = new Set();
147+
vis.add(0);
148+
for (; i < n; ++i) {
149+
s += nums[i];
150+
if (vis.has(s - target)) {
151+
++ans;
152+
break;
153+
}
154+
vis.add(s);
155+
}
156+
}
157+
return ans;
136158
}
137159
```
138160

Lines changed: 19 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -1,23 +1,20 @@
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-
int s = 0;
8-
unordered_set<int> seen;
9-
seen.insert(0);
10-
while (i < n) {
11-
s += nums[i];
12-
if (seen.count(s - target)) {
13-
++ans;
14-
break;
15-
}
16-
++i;
17-
seen.insert(s);
18-
}
19-
++i;
20-
}
21-
return ans;
22-
}
1+
class Solution {
2+
public:
3+
int maxNonOverlapping(vector<int>& nums, int target) {
4+
int ans = 0, n = nums.size();
5+
for (int i = 0; i < n; ++i) {
6+
unordered_set<int> vis{{0}};
7+
int s = 0;
8+
while (i < n) {
9+
s += nums[i];
10+
if (vis.count(s - target)) {
11+
++ans;
12+
break;
13+
}
14+
++i;
15+
vis.insert(s);
16+
}
17+
}
18+
return ans;
19+
}
2320
};
Lines changed: 8 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -1,18 +1,16 @@
1-
func maxNonOverlapping(nums []int, target int) int {
2-
i, n, ans:= 0, len(nums), 0
3-
for i < n {
1+
func maxNonOverlapping(nums []int, target int) (ansint) {
2+
n:= len(nums)
3+
for i :=0; i< n; i++ {
44
s := 0
5-
seen := map[int]bool{0: true}
6-
for i < n {
5+
vis := map[int]bool{0: true}
6+
for ; i < n; i++ {
77
s += nums[i]
8-
if seen[s-target] {
8+
if vis[s-target] {
99
ans++
1010
break
1111
}
12-
seen[s] = true
13-
i++
12+
vis[s] = true
1413
}
15-
i++
1614
}
17-
returnans
15+
return
1816
}

0 commit comments

Comments
(0)

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