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 58f1e18

Browse files
committed
feat: add solutions to lc problems: No.0689,2095
* No.0689.Maximum Sum of 3 Non-Overlapping Subarrays * No.2095.Delete the Middle Node of a Linked List
1 parent 2970f5e commit 58f1e18

File tree

10 files changed

+535
-21
lines changed

10 files changed

+535
-21
lines changed

‎solution/0600-0699/0689.Maximum Sum of 3 Non-Overlapping Subarrays/README.md‎

Lines changed: 135 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -29,27 +29,160 @@
2929
<li><code>k</code>的范围在<code>[1, floor(nums.length / 3)]</code>之间。</li>
3030
</ul>
3131

32-
3332
## 解法
3433

3534
<!-- 这里可写通用的实现逻辑 -->
3635

36+
滑动窗口,枚举第三个子数组的位置,同时维护前两个无重叠子数组的最大和及其位置。
37+
3738
<!-- tabs:start -->
3839

3940
### **Python3**
4041

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

4344
```python
44-
45+
class Solution:
46+
def maxSumOfThreeSubarrays(self, nums: List[int], k: int) -> List[int]:
47+
s = s1 = s2 = s3 = 0
48+
mx1 = mx12 = 0
49+
idx1, idx12 = 0, ()
50+
ans = []
51+
for i in range(k * 2, len(nums)):
52+
s1 += nums[i - k * 2]
53+
s2 += nums[i - k]
54+
s3 += nums[i]
55+
if i >= k * 3 - 1:
56+
if s1 > mx1:
57+
mx1 = s1
58+
idx1 = i - k * 3 + 1
59+
if mx1 + s2 > mx12:
60+
mx12 = mx1 + s2
61+
idx12 = (idx1, i - k * 2 + 1)
62+
if mx12 + s3 > s:
63+
s = mx12 + s3
64+
ans = [*idx12, i - k + 1]
65+
s1 -= nums[i - k * 3 + 1]
66+
s2 -= nums[i - k * 2 + 1]
67+
s3 -= nums[i - k + 1]
68+
return ans
4569
```
4670

4771
### **Java**
4872

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

5175
```java
76+
class Solution {
77+
public int[] maxSumOfThreeSubarrays(int[] nums, int k) {
78+
int[] ans = new int[3];
79+
int s = 0, s1 = 0, s2 = 0, s3 = 0;
80+
int mx1 = 0, mx12 = 0;
81+
int idx1 = 0, idx121 = 0, idx122 = 0;
82+
for (int i = k * 2; i < nums.length; ++i) {
83+
s1 += nums[i - k * 2];
84+
s2 += nums[i - k];
85+
s3 += nums[i];
86+
if (i >= k * 3 - 1) {
87+
if (s1 > mx1) {
88+
mx1 = s1;
89+
idx1 = i - k * 3 + 1;
90+
}
91+
if (mx1 + s2 > mx12) {
92+
mx12 = mx1 + s2;
93+
idx121 = idx1;
94+
idx122 = i - k * 2 + 1;
95+
}
96+
if (mx12 + s3 > s) {
97+
s = mx12 + s3;
98+
ans = new int[]{idx121, idx122, i - k + 1};
99+
}
100+
s1 -= nums[i - k * 3 + 1];
101+
s2 -= nums[i - k * 2 + 1];
102+
s3 -= nums[i - k + 1];
103+
}
104+
}
105+
return ans;
106+
}
107+
}
108+
```
109+
110+
### **C++**
111+
112+
```cpp
113+
class Solution {
114+
public:
115+
vector<int> maxSumOfThreeSubarrays(vector<int>& nums, int k) {
116+
vector<int> ans(3);
117+
int s = 0, s1 = 0, s2 = 0, s3 = 0;
118+
int mx1 = 0, mx12 = 0;
119+
int idx1 = 0, idx121 = 0, idx122 = 0;
120+
for (int i = k * 2; i < nums.size(); ++i)
121+
{
122+
s1 += nums[i - k * 2];
123+
s2 += nums[i - k];
124+
s3 += nums[i];
125+
if (i >= k * 3 - 1)
126+
{
127+
if (s1 > mx1)
128+
{
129+
mx1 = s1;
130+
idx1 = i - k * 3 + 1;
131+
}
132+
if (mx1 + s2 > mx12)
133+
{
134+
mx12 = mx1 + s2;
135+
idx121 = idx1;
136+
idx122 = i - k * 2 + 1;
137+
}
138+
if (mx12 + s3 > s)
139+
{
140+
s = mx12 + s3;
141+
ans = {idx121, idx122, i - k + 1};
142+
}
143+
s1 -= nums[i - k * 3 + 1];
144+
s2 -= nums[i - k * 2 + 1];
145+
s3 -= nums[i - k + 1];
146+
}
147+
}
148+
return ans;
149+
}
150+
};
151+
```
52152
153+
### **Go**
154+
155+
```go
156+
func maxSumOfThreeSubarrays(nums []int, k int) []int {
157+
ans := make([]int, 3)
158+
s, s1, s2, s3 := 0, 0, 0, 0
159+
mx1, mx12 := 0, 0
160+
idx1, idx121, idx122 := 0, 0, 0
161+
for i := k * 2; i < len(nums); i++ {
162+
s1 += nums[i-k*2]
163+
s2 += nums[i-k]
164+
s3 += nums[i]
165+
if i >= k*3-1 {
166+
if s1 > mx1 {
167+
mx1 = s1
168+
idx1 = i - k*3 + 1
169+
}
170+
if mx1+s2 > mx12 {
171+
mx12 = mx1 + s2
172+
idx121 = idx1
173+
idx122 = i - k*2 + 1
174+
}
175+
if mx12+s3 > s {
176+
s = mx12 + s3
177+
ans = []int{idx121, idx122, i - k + 1}
178+
}
179+
s1 -= nums[i-k*3+1]
180+
s2 -= nums[i-k*2+1]
181+
s3 -= nums[i-k+1]
182+
}
183+
}
184+
return ans
185+
}
53186
```
54187

55188
### **...**

‎solution/0600-0699/0689.Maximum Sum of 3 Non-Overlapping Subarrays/README_EN.md‎

Lines changed: 133 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -6,20 +6,12 @@
66

77
<p>In a given array <code>nums</code> of positive integers, find three non-overlapping subarrays with maximum sum.</p>
88

9-
10-
119
<p>Each subarray will be of size <code>k</code>, and we want to maximize the sum of all <code>3*k</code> entries.</p>
1210

13-
14-
1511
<p>Return the result as a list of indices representing the starting position of each interval (0-indexed). If there are multiple answers, return the lexicographically smallest one.</p>
1612

17-
18-
1913
<p><b>Example:</b></p>
2014

21-
22-
2315
<pre>
2416

2517
<b>Input:</b> [1,2,1,2,6,7,5,1], 2
@@ -32,42 +24,164 @@ We could have also taken [2, 1], but an answer of [1, 3, 5] would be lexicograph
3224

3325
</pre>
3426

35-
36-
3727
<p>&nbsp;</p>
3828

39-
40-
4129
<p><b>Note:</b></p>
4230

43-
44-
4531
<ul>
4632
<li><code>nums.length</code> will be between 1 and 20000.</li>
4733
<li><code>nums[i]</code> will be between 1 and 65535.</li>
4834
<li><code>k</code> will be between 1 and floor(nums.length / 3).</li>
4935
</ul>
5036

51-
52-
5337
<p>&nbsp;</p>
5438

55-
56-
5739
## Solutions
5840

5941
<!-- tabs:start -->
6042

6143
### **Python3**
6244

6345
```python
64-
46+
class Solution:
47+
def maxSumOfThreeSubarrays(self, nums: List[int], k: int) -> List[int]:
48+
s = s1 = s2 = s3 = 0
49+
mx1 = mx12 = 0
50+
idx1, idx12 = 0, ()
51+
ans = []
52+
for i in range(k * 2, len(nums)):
53+
s1 += nums[i - k * 2]
54+
s2 += nums[i - k]
55+
s3 += nums[i]
56+
if i >= k * 3 - 1:
57+
if s1 > mx1:
58+
mx1 = s1
59+
idx1 = i - k * 3 + 1
60+
if mx1 + s2 > mx12:
61+
mx12 = mx1 + s2
62+
idx12 = (idx1, i - k * 2 + 1)
63+
if mx12 + s3 > s:
64+
s = mx12 + s3
65+
ans = [*idx12, i - k + 1]
66+
s1 -= nums[i - k * 3 + 1]
67+
s2 -= nums[i - k * 2 + 1]
68+
s3 -= nums[i - k + 1]
69+
return ans
6570
```
6671

6772
### **Java**
6873

6974
```java
75+
class Solution {
76+
public int[] maxSumOfThreeSubarrays(int[] nums, int k) {
77+
int[] ans = new int[3];
78+
int s = 0, s1 = 0, s2 = 0, s3 = 0;
79+
int mx1 = 0, mx12 = 0;
80+
int idx1 = 0, idx121 = 0, idx122 = 0;
81+
for (int i = k * 2; i < nums.length; ++i) {
82+
s1 += nums[i - k * 2];
83+
s2 += nums[i - k];
84+
s3 += nums[i];
85+
if (i >= k * 3 - 1) {
86+
if (s1 > mx1) {
87+
mx1 = s1;
88+
idx1 = i - k * 3 + 1;
89+
}
90+
if (mx1 + s2 > mx12) {
91+
mx12 = mx1 + s2;
92+
idx121 = idx1;
93+
idx122 = i - k * 2 + 1;
94+
}
95+
if (mx12 + s3 > s) {
96+
s = mx12 + s3;
97+
ans = new int[]{idx121, idx122, i - k + 1};
98+
}
99+
s1 -= nums[i - k * 3 + 1];
100+
s2 -= nums[i - k * 2 + 1];
101+
s3 -= nums[i - k + 1];
102+
}
103+
}
104+
return ans;
105+
}
106+
}
107+
```
108+
109+
### **C++**
110+
111+
```cpp
112+
class Solution {
113+
public:
114+
vector<int> maxSumOfThreeSubarrays(vector<int>& nums, int k) {
115+
vector<int> ans(3);
116+
int s = 0, s1 = 0, s2 = 0, s3 = 0;
117+
int mx1 = 0, mx12 = 0;
118+
int idx1 = 0, idx121 = 0, idx122 = 0;
119+
for (int i = k * 2; i < nums.size(); ++i)
120+
{
121+
s1 += nums[i - k * 2];
122+
s2 += nums[i - k];
123+
s3 += nums[i];
124+
if (i >= k * 3 - 1)
125+
{
126+
if (s1 > mx1)
127+
{
128+
mx1 = s1;
129+
idx1 = i - k * 3 + 1;
130+
}
131+
if (mx1 + s2 > mx12)
132+
{
133+
mx12 = mx1 + s2;
134+
idx121 = idx1;
135+
idx122 = i - k * 2 + 1;
136+
}
137+
if (mx12 + s3 > s)
138+
{
139+
s = mx12 + s3;
140+
ans = {idx121, idx122, i - k + 1};
141+
}
142+
s1 -= nums[i - k * 3 + 1];
143+
s2 -= nums[i - k * 2 + 1];
144+
s3 -= nums[i - k + 1];
145+
}
146+
}
147+
return ans;
148+
}
149+
};
150+
```
70151
152+
### **Go**
153+
154+
```go
155+
func maxSumOfThreeSubarrays(nums []int, k int) []int {
156+
ans := make([]int, 3)
157+
s, s1, s2, s3 := 0, 0, 0, 0
158+
mx1, mx12 := 0, 0
159+
idx1, idx121, idx122 := 0, 0, 0
160+
for i := k * 2; i < len(nums); i++ {
161+
s1 += nums[i-k*2]
162+
s2 += nums[i-k]
163+
s3 += nums[i]
164+
if i >= k*3-1 {
165+
if s1 > mx1 {
166+
mx1 = s1
167+
idx1 = i - k*3 + 1
168+
}
169+
if mx1+s2 > mx12 {
170+
mx12 = mx1 + s2
171+
idx121 = idx1
172+
idx122 = i - k*2 + 1
173+
}
174+
if mx12+s3 > s {
175+
s = mx12 + s3
176+
ans = []int{idx121, idx122, i - k + 1}
177+
}
178+
s1 -= nums[i-k*3+1]
179+
s2 -= nums[i-k*2+1]
180+
s3 -= nums[i-k+1]
181+
}
182+
}
183+
return ans
184+
}
71185
```
72186

73187
### **...**
Lines changed: 38 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,38 @@
1+
class Solution {
2+
public:
3+
vector<int> maxSumOfThreeSubarrays(vector<int>& nums, int k) {
4+
vector<int> ans(3);
5+
int s = 0, s1 = 0, s2 = 0, s3 = 0;
6+
int mx1 = 0, mx12 = 0;
7+
int idx1 = 0, idx121 = 0, idx122 = 0;
8+
for (int i = k * 2; i < nums.size(); ++i)
9+
{
10+
s1 += nums[i - k * 2];
11+
s2 += nums[i - k];
12+
s3 += nums[i];
13+
if (i >= k * 3 - 1)
14+
{
15+
if (s1 > mx1)
16+
{
17+
mx1 = s1;
18+
idx1 = i - k * 3 + 1;
19+
}
20+
if (mx1 + s2 > mx12)
21+
{
22+
mx12 = mx1 + s2;
23+
idx121 = idx1;
24+
idx122 = i - k * 2 + 1;
25+
}
26+
if (mx12 + s3 > s)
27+
{
28+
s = mx12 + s3;
29+
ans = {idx121, idx122, i - k + 1};
30+
}
31+
s1 -= nums[i - k * 3 + 1];
32+
s2 -= nums[i - k * 2 + 1];
33+
s3 -= nums[i - k + 1];
34+
}
35+
}
36+
return ans;
37+
}
38+
};

0 commit comments

Comments
(0)

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