Skip to content

Commit ba273aa

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.3499 (#4310)
No.3499.Maximize Active Section with Trade I
1 parent fb258cf commit ba273aa

File tree

7 files changed

+368
-8
lines changed

7 files changed

+368
-8
lines changed

‎solution/3400-3499/3499.Maximize Active Section with Trade I/README.md

+127-4
Original file line numberDiff line numberDiff line change
@@ -109,32 +109,155 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3400-3499/3499.Ma
109109

110110
<!-- solution:start -->
111111

112-
### 方法一
112+
### 方法一：贪心 + 双指针
113+
114+
题目实际上等价于求字符串 $\textit{s}$ 中，字符 `'1'` 的数量，再加上相邻两个连续的字符 `'0'` 串中 ``'0'` 的最大数量。
115+
116+
因此，我们可以使用双指针来遍历字符串 $\textit{s}$，用一个变量 $\textit{mx}$ 来记录相邻两个连续的字符 `'0'` 串中 `'0'` 的最大数量。我们还需要一个变量 $\textit{pre}$ 来记录上一个连续的字符 `'0'` 串的数量。
117+
118+
每一次，我们统计当前连续相同字符的数量 $\textit{cnt}$，如果当前字符为 `'1'`，则将 $\textit{cnt}$ 加入到答案中；如果当前字符为 `'0'`，则将 $\textit{mx}$ 更新为 $\textit{mx} = \max(\textit{mx}, \textit{pre} + \textit{cnt})$，并将 $\textit{pre}$ 更新为 $\textit{cnt}$。最后，我们将答案加上 $\textit{mx}$ 即可。
119+
120+
时间复杂度 $O(n)$，其中 $n$ 为字符串 $\textit{s}$ 的长度。空间复杂度 $O(1)$。
113121

114122
<!-- tabs:start -->
115123

116124
#### Python3
117125

118126
```python
119-
127+
class Solution:
128+
def maxActiveSectionsAfterTrade(self, s: str) -> int:
129+
n = len(s)
130+
ans = i = 0
131+
pre, mx = -inf, 0
132+
while i < n:
133+
j = i + 1
134+
while j < n and s[j] == s[i]:
135+
j += 1
136+
cur = j - i
137+
if s[i] == "1":
138+
ans += cur
139+
else:
140+
mx = max(mx, pre + cur)
141+
pre = cur
142+
i = j
143+
ans += mx
144+
return ans
120145
```
121146

122147
#### Java
123148

124149
```java
125-
150+
class Solution {
151+
public int maxActiveSectionsAfterTrade(String s) {
152+
int n = s.length();
153+
int ans = 0, i = 0;
154+
int pre = Integer.MIN_VALUE, mx = 0;
155+
156+
while (i < n) {
157+
int j = i + 1;
158+
while (j < n && s.charAt(j) == s.charAt(i)) {
159+
j++;
160+
}
161+
int cur = j - i;
162+
if (s.charAt(i) == '1') {
163+
ans += cur;
164+
} else {
165+
mx = Math.max(mx, pre + cur);
166+
pre = cur;
167+
}
168+
i = j;
169+
}
170+
171+
ans += mx;
172+
return ans;
173+
}
174+
}
126175
```
127176

128177
#### C++
129178

130179
```cpp
131-
180+
class Solution {
181+
public:
182+
int maxActiveSectionsAfterTrade(std::string s) {
183+
int n = s.length();
184+
int ans = 0, i = 0;
185+
int pre = INT_MIN, mx = 0;
186+
187+
while (i < n) {
188+
int j = i + 1;
189+
while (j < n && s[j] == s[i]) {
190+
j++;
191+
}
192+
int cur = j - i;
193+
if (s[i] == '1') {
194+
ans += cur;
195+
} else {
196+
mx = std::max(mx, pre + cur);
197+
pre = cur;
198+
}
199+
i = j;
200+
}
201+
202+
ans += mx;
203+
return ans;
204+
}
205+
};
132206
```
133207

134208
#### Go
135209

136210
```go
211+
func maxActiveSectionsAfterTrade(s string) (ans int) {
212+
n := len(s)
213+
pre, mx := math.MinInt, 0
214+
215+
for i := 0; i < n; {
216+
j := i + 1
217+
for j < n && s[j] == s[i] {
218+
j++
219+
}
220+
cur := j - i
221+
if s[i] == '1' {
222+
ans += cur
223+
} else {
224+
mx = max(mx, pre+cur)
225+
pre = cur
226+
}
227+
i = j
228+
}
229+
230+
ans += mx
231+
return
232+
}
233+
```
137234

235+
#### TypeScript
236+
237+
```ts
238+
function maxActiveSectionsAfterTrade(s: string): number {
239+
let n = s.length;
240+
let [ans, mx] = [0, 0];
241+
let pre = Number.MIN_SAFE_INTEGER;
242+
243+
for (let i = 0; i < n; ) {
244+
let j = i + 1;
245+
while (j < n && s[j] === s[i]) {
246+
j++;
247+
}
248+
let cur = j - i;
249+
if (s[i] === '1') {
250+
ans += cur;
251+
} else {
252+
mx = Math.max(mx, pre + cur);
253+
pre = cur;
254+
}
255+
i = j;
256+
}
257+
258+
ans += mx;
259+
return ans;
260+
}
138261
```
139262

140263
<!-- tabs:end -->

‎solution/3400-3499/3499.Maximize Active Section with Trade I/README_EN.md

+127-4
Original file line numberDiff line numberDiff line change
@@ -107,32 +107,155 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3400-3499/3499.Ma
107107

108108
<!-- solution:start -->
109109

110-
### Solution 1
110+
### Solution 1: Greedy + Two Pointers
111+
112+
The problem is essentially equivalent to finding the number of `'1'` characters in the string $\textit{s}$, plus the maximum number of `'0'` characters in two adjacent consecutive `'0'` segments.
113+
114+
Thus, we can use two pointers to traverse the string $\textit{s}$. Use a variable $\textit{mx}$ to record the maximum number of `'0'` characters in two adjacent consecutive `'0'` segments. We also need a variable $\textit{pre}$ to record the number of `'0'` characters in the previous consecutive `'0'` segment.
115+
116+
Each time, we count the number of consecutive identical characters $\textit{cnt}$. If the current character is `'1'`, add $\textit{cnt}$ to the answer. If the current character is `'0'`, update $\textit{mx}$ as $\textit{mx} = \max(\textit{mx}, \textit{pre} + \textit{cnt})$, and update $\textit{pre}$ to $\textit{cnt}$. Finally, add $\textit{mx}$ to the answer.
117+
118+
Time complexity is $O(n)$, where $n$ is the length of the string $\textit{s}$. Space complexity is $O(1)$.
111119

112120
<!-- tabs:start -->
113121

114122
#### Python3
115123

116124
```python
117-
125+
class Solution:
126+
def maxActiveSectionsAfterTrade(self, s: str) -> int:
127+
n = len(s)
128+
ans = i = 0
129+
pre, mx = -inf, 0
130+
while i < n:
131+
j = i + 1
132+
while j < n and s[j] == s[i]:
133+
j += 1
134+
cur = j - i
135+
if s[i] == "1":
136+
ans += cur
137+
else:
138+
mx = max(mx, pre + cur)
139+
pre = cur
140+
i = j
141+
ans += mx
142+
return ans
118143
```
119144

120145
#### Java
121146

122147
```java
123-
148+
class Solution {
149+
public int maxActiveSectionsAfterTrade(String s) {
150+
int n = s.length();
151+
int ans = 0, i = 0;
152+
int pre = Integer.MIN_VALUE, mx = 0;
153+
154+
while (i < n) {
155+
int j = i + 1;
156+
while (j < n && s.charAt(j) == s.charAt(i)) {
157+
j++;
158+
}
159+
int cur = j - i;
160+
if (s.charAt(i) == '1') {
161+
ans += cur;
162+
} else {
163+
mx = Math.max(mx, pre + cur);
164+
pre = cur;
165+
}
166+
i = j;
167+
}
168+
169+
ans += mx;
170+
return ans;
171+
}
172+
}
124173
```
125174

126175
#### C++
127176

128177
```cpp
129-
178+
class Solution {
179+
public:
180+
int maxActiveSectionsAfterTrade(std::string s) {
181+
int n = s.length();
182+
int ans = 0, i = 0;
183+
int pre = INT_MIN, mx = 0;
184+
185+
while (i < n) {
186+
int j = i + 1;
187+
while (j < n && s[j] == s[i]) {
188+
j++;
189+
}
190+
int cur = j - i;
191+
if (s[i] == '1') {
192+
ans += cur;
193+
} else {
194+
mx = std::max(mx, pre + cur);
195+
pre = cur;
196+
}
197+
i = j;
198+
}
199+
200+
ans += mx;
201+
return ans;
202+
}
203+
};
130204
```
131205

132206
#### Go
133207

134208
```go
209+
func maxActiveSectionsAfterTrade(s string) (ans int) {
210+
n := len(s)
211+
pre, mx := math.MinInt, 0
212+
213+
for i := 0; i < n; {
214+
j := i + 1
215+
for j < n && s[j] == s[i] {
216+
j++
217+
}
218+
cur := j - i
219+
if s[i] == '1' {
220+
ans += cur
221+
} else {
222+
mx = max(mx, pre+cur)
223+
pre = cur
224+
}
225+
i = j
226+
}
227+
228+
ans += mx
229+
return
230+
}
231+
```
135232

233+
#### TypeScript
234+
235+
```ts
236+
function maxActiveSectionsAfterTrade(s: string): number {
237+
let n = s.length;
238+
let [ans, mx] = [0, 0];
239+
let pre = Number.MIN_SAFE_INTEGER;
240+
241+
for (let i = 0; i < n; ) {
242+
let j = i + 1;
243+
while (j < n && s[j] === s[i]) {
244+
j++;
245+
}
246+
let cur = j - i;
247+
if (s[i] === '1') {
248+
ans += cur;
249+
} else {
250+
mx = Math.max(mx, pre + cur);
251+
pre = cur;
252+
}
253+
i = j;
254+
}
255+
256+
ans += mx;
257+
return ans;
258+
}
136259
```
137260

138261
<!-- tabs:end -->

‎solution/3400-3499/3499.Maximize Active Section with Trade I/Solution.cpp

+26
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
class Solution {
2+
public:
3+
int maxActiveSectionsAfterTrade(std::string s) {
4+
int n = s.length();
5+
int ans = 0, i = 0;
6+
int pre = INT_MIN, mx = 0;
7+
8+
while (i < n) {
9+
int j = i + 1;
10+
while (j < n && s[j] == s[i]) {
11+
j++;
12+
}
13+
int cur = j - i;
14+
if (s[i] == '1') {
15+
ans += cur;
16+
} else {
17+
mx = std::max(mx, pre + cur);
18+
pre = cur;
19+
}
20+
i = j;
21+
}
22+
23+
ans += mx;
24+
return ans;
25+
}
26+
};

‎solution/3400-3499/3499.Maximize Active Section with Trade I/Solution.go

+22
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,22 @@
1+
func maxActiveSectionsAfterTrade(s string) (ans int) {
2+
n := len(s)
3+
pre, mx := math.MinInt, 0
4+
5+
for i := 0; i < n; {
6+
j := i + 1
7+
for j < n && s[j] == s[i] {
8+
j++
9+
}
10+
cur := j - i
11+
if s[i] == '1' {
12+
ans += cur
13+
} else {
14+
mx = max(mx, pre+cur)
15+
pre = cur
16+
}
17+
i = j
18+
}
19+
20+
ans += mx
21+
return
22+
}

‎solution/3400-3499/3499.Maximize Active Section with Trade I/Solution.java

+25
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
class Solution {
2+
public int maxActiveSectionsAfterTrade(String s) {
3+
int n = s.length();
4+
int ans = 0, i = 0;
5+
int pre = Integer.MIN_VALUE, mx = 0;
6+
7+
while (i < n) {
8+
int j = i + 1;
9+
while (j < n && s.charAt(j) == s.charAt(i)) {
10+
j++;
11+
}
12+
int cur = j - i;
13+
if (s.charAt(i) == '1') {
14+
ans += cur;
15+
} else {
16+
mx = Math.max(mx, pre + cur);
17+
pre = cur;
18+
}
19+
i = j;
20+
}
21+
22+
ans += mx;
23+
return ans;
24+
}
25+
}

0 commit comments

Comments
 (0)