Skip to content

Commit 964988d

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0209. Minimum Size Subarray Sum
1 parent efc0494 commit 964988d

File tree

5 files changed

+264
-34
lines changed

5 files changed

+264
-34
lines changed

Diff for: ‎solution/0200-0299/0209.Minimum Size Subarray Sum/README.md

+115-1
Original file line numberDiff line numberDiff line change
@@ -52,27 +52,141 @@
5252
<li>如果你已经实现<em> </em><code>O(n)</code> 时间复杂度的解法, 请尝试设计一个 <code>O(n log(n))</code> 时间复杂度的解法。</li>
5353
</ul>
5454

55-
5655
## 解法
5756

5857
<!-- 这里可写通用的实现逻辑 -->
5958

59+
“前缀和 + 二分查找”，先求出数组的前缀和 `preSum`，然后根据 `preSum[i] - preSum[j] >= target` => `preSum[i] >= preSum[j] + target`，对 `preSum[i]` 进行二分查找，然后更新最小长度即可。时间复杂度 `O(n logn)`。
60+
61+
也可以用“滑动窗口”。
62+
63+
使用指针 left, right 分别表示子数组的开始位置和结束位置，维护变量 sum 表示子数组 `nums[left...right]` 元素之和。初始时 left, right 均指向 0。每一次迭代，将 `nums[right]` 加到 sum，如果此时 `sum >= target`，更新最小长度即可。然后将 sum 减去 `nums[left]`，接着 left 指针右移直至 `sum < target`。每一次迭代最后，将 right 指针右移。时间复杂度 `O(n)`。
64+
6065
<!-- tabs:start -->
6166

6267
### **Python3**
6368

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

71+
“前缀和 + 二分查找”。
72+
6673
```python
74+
class Solution:
75+
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
76+
n = len(nums)
77+
pre_sum = [0] * (n + 1)
78+
for i in range(1, n + 1):
79+
pre_sum[i] = pre_sum[i - 1] + nums[i - 1]
80+
res = n + 1
81+
for i in range(1, n + 1):
82+
t = pre_sum[i - 1] + target
83+
left, right = 0, n
84+
while left < right:
85+
mid = (left + right) >> 1
86+
if pre_sum[mid] >= t:
87+
right = mid
88+
else:
89+
left = mid + 1
90+
if pre_sum[left] - pre_sum[i - 1] >= target:
91+
res = min(res, left - i + 1)
92+
return 0 if res == n + 1 else res
93+
```
94+
95+
“滑动窗口”。
6796

97+
```python
98+
class Solution:
99+
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
100+
n = len(nums)
101+
left = right = 0
102+
sum, res = 0, n + 1
103+
while right < n:
104+
sum += nums[right]
105+
while sum >= target:
106+
res = min(res, right - left + 1)
107+
sum -= nums[left]
108+
left += 1
109+
right += 1
110+
return 0 if res == n + 1 else res
68111
```
69112

70113
### **Java**
71114

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

117+
“前缀和 + 二分查找”。
118+
74119
```java
120+
class Solution {
121+
public int minSubArrayLen(int target, int[] nums) {
122+
int n = nums.length;
123+
int[] preSum = new int[n + 1];
124+
for (int i = 1; i <= n; ++i) {
125+
preSum[i] = preSum[i - 1] +nums[i - 1];
126+
}
127+
int res = n + 1;
128+
for (int i = 1; i <= n; ++i) {
129+
int t = preSum[i - 1] + target;
130+
int left = 0, right = n;
131+
while (left < right) {
132+
int mid = (left + right) >> 1;
133+
if (preSum[mid] >= t) {
134+
right = mid;
135+
} else {
136+
left = mid + 1;
137+
}
138+
}
139+
if (preSum[left] - preSum[i - 1] >= target) {
140+
res = Math.min(res, left - i + 1);
141+
}
142+
}
143+
return res == n + 1 ? 0 : res;
144+
}
145+
}
146+
```
147+
148+
“滑动窗口”。
149+
150+
```java
151+
class Solution {
152+
public int minSubArrayLen(int target, int[] nums) {
153+
int n = nums.length;
154+
int left = 0, right = 0;
155+
int sum = 0, res = n + 1;
156+
while (right < n) {
157+
sum += nums[right];
158+
while (sum >= target) {
159+
res = Math.min(res, right - left + 1);
160+
sum -= nums[left++];
161+
}
162+
++right;
163+
}
164+
return res == n + 1 ? 0 : res;
165+
}
166+
}
167+
```
75168

169+
### **C#**
170+
171+
```cs
172+
public class Solution {
173+
public int MinSubArrayLen(int target, int[] nums) {
174+
int n = nums.Length;
175+
int left = 0, right = 0;
176+
int sum = 0, res = n + 1;
177+
while (right < n)
178+
{
179+
sum += nums[right];
180+
while (sum >= target)
181+
{
182+
res = Math.Min(res, right - left + 1);
183+
sum -= nums[left++];
184+
}
185+
++right;
186+
}
187+
return res == n + 1 ? 0 : res;
188+
}
189+
}
76190
```
77191

78192
### **...**

Diff for: ‎solution/0200-0299/0209.Minimum Size Subarray Sum/README_EN.md

+109
Original file line numberDiff line numberDiff line change
@@ -47,14 +47,123 @@
4747

4848
### **Python3**
4949

50+
Presum and binary search.
51+
5052
```python
53+
class Solution:
54+
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
55+
n = len(nums)
56+
pre_sum = [0] * (n + 1)
57+
for i in range(1, n + 1):
58+
pre_sum[i] = pre_sum[i - 1] + nums[i - 1]
59+
res = n + 1
60+
for i in range(1, n + 1):
61+
t = pre_sum[i - 1] + target
62+
left, right = 0, n
63+
while left < right:
64+
mid = (left + right) >> 1
65+
if pre_sum[mid] >= t:
66+
right = mid
67+
else:
68+
left = mid + 1
69+
if pre_sum[left] - pre_sum[i - 1] >= target:
70+
res = min(res, left - i + 1)
71+
return 0 if res == n + 1 else res
72+
```
73+
74+
Slide window.
5175

76+
```python
77+
class Solution:
78+
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
79+
n = len(nums)
80+
left = right = 0
81+
sum, res = 0, n + 1
82+
while right < n:
83+
sum += nums[right]
84+
while sum >= target:
85+
res = min(res, right - left + 1)
86+
sum -= nums[left]
87+
left += 1
88+
right += 1
89+
return 0 if res == n + 1 else res
5290
```
5391

5492
### **Java**
5593

94+
Presum and binary search.
95+
5696
```java
97+
class Solution {
98+
public int minSubArrayLen(int target, int[] nums) {
99+
int n = nums.length;
100+
int[] preSum = new int[n + 1];
101+
for (int i = 1; i <= n; ++i) {
102+
preSum[i] = preSum[i - 1] +nums[i - 1];
103+
}
104+
int res = n + 1;
105+
for (int i = 1; i <= n; ++i) {
106+
int t = preSum[i - 1] + target;
107+
int left = 0, right = n;
108+
while (left < right) {
109+
int mid = (left + right) >> 1;
110+
if (preSum[mid] >= t) {
111+
right = mid;
112+
} else {
113+
left = mid + 1;
114+
}
115+
}
116+
if (preSum[left] - preSum[i - 1] >= target) {
117+
res = Math.min(res, left - i + 1);
118+
}
119+
}
120+
return res == n + 1 ? 0 : res;
121+
}
122+
}
123+
```
124+
125+
Slide window.
126+
127+
```java
128+
class Solution {
129+
public int minSubArrayLen(int target, int[] nums) {
130+
int n = nums.length;
131+
int left = 0, right = 0;
132+
int sum = 0, res = n + 1;
133+
while (right < n) {
134+
sum += nums[right];
135+
while (sum >= target) {
136+
res = Math.min(res, right - left + 1);
137+
sum -= nums[left++];
138+
}
139+
++right;
140+
}
141+
return res == n + 1 ? 0 : res;
142+
}
143+
}
144+
```
57145

146+
### **C#**
147+
148+
```cs
149+
public class Solution {
150+
public int MinSubArrayLen(int target, int[] nums) {
151+
int n = nums.Length;
152+
int left = 0, right = 0;
153+
int sum = 0, res = n + 1;
154+
while (right < n)
155+
{
156+
sum += nums[right];
157+
while (sum >= target)
158+
{
159+
res = Math.Min(res, right - left + 1);
160+
sum -= nums[left++];
161+
}
162+
++right;
163+
}
164+
return res == n + 1 ? 0 : res;
165+
}
166+
}
58167
```
59168

60169
### **...**

Diff for: ‎solution/0200-0299/0209.Minimum Size Subarray Sum/Solution.cs

+11-19
Original file line numberDiff line numberDiff line change
@@ -1,26 +1,18 @@
1-
using System;
2-
31
public class Solution {
4-
public int MinSubArrayLen(int s, int[] nums) {
5-
var result = int.MaxValue;
6-
var l = 0;
7-
var r = -1;
8-
var sum = 0;
9-
while (r + 1 < nums.Length)
2+
public int MinSubArrayLen(int target, int[] nums) {
3+
int n = nums.Length;
4+
int left = 0, right = 0;
5+
int sum = 0, res = n + 1;
6+
while (right < n)
107
{
11-
sum += nums[++r];
12-
while (sum - nums[l] >= s)
8+
sum += nums[right];
9+
while (sum >= target)
1310
{
14-
sum -= nums[l++];
15-
}
16-
if (sum >= s)
17-
{
18-
result = Math.Min(result, r - l + 1);
19-
sum -= nums[l++];
11+
res = Math.Min(res, right - left + 1);
12+
sum -= nums[left++];
2013
}
14+
++right;
2115
}
22-
23-
if (result == int.MaxValue) result = 0;
24-
return result;
16+
return res == n + 1 ? 0 : res;
2517
}
2618
}

Diff for: ‎solution/0200-0299/0209.Minimum Size Subarray Sum/Solution.java

+10-14
Original file line numberDiff line numberDiff line change
@@ -1,20 +1,16 @@
11
class Solution {
2-
public int minSubArrayLen(int s, int[] nums) {
2+
public int minSubArrayLen(int target, int[] nums) {
33
int n = nums.length;
4-
int ans = Integer.MAX_VALUE;
5-
int start = 0, end = 0;
6-
int sum = 0;
7-
while (start < n) {
8-
while (end < n && sum < s) {
9-
sum += nums[end];
10-
end++;
4+
int left = 0, right = 0;
5+
int sum = 0, res = n + 1;
6+
while (right < n) {
7+
sum += nums[right];
8+
while (sum >= target) {
9+
res = Math.min(res, right - left + 1);
10+
sum -= nums[left++];
1111
}
12-
if (sum >= s) {
13-
ans = Math.min(ans, end - start);
14-
}
15-
sum -= nums[start];
16-
start++;
12+
++right;
1713
}
18-
return ans == Integer.MAX_VALUE ? 0 : ans;
14+
return res == n + 1 ? 0 : res;
1915
}
2016
}

Diff for: ‎solution/0200-0299/0209.Minimum Size Subarray Sum/Solution.py

+19
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,19 @@
1+
class Solution:
2+
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
3+
n = len(nums)
4+
pre_sum = [0] * (n + 1)
5+
for i in range(1, n + 1):
6+
pre_sum[i] = pre_sum[i - 1] + nums[i - 1]
7+
res = n + 1
8+
for i in range(1, n + 1):
9+
t = pre_sum[i - 1] + target
10+
left, right = 0, n
11+
while left < right:
12+
mid = (left + right) >> 1
13+
if pre_sum[mid] >= t:
14+
right = mid
15+
else:
16+
left = mid + 1
17+
if pre_sum[left] - pre_sum[i - 1] >= target:
18+
res = min(res, left - i + 1)
19+
return 0 if res == n + 1 else res

0 commit comments

Comments
 (0)