Skip to content

Commit ad956dd

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1477
No.1477.Find Two Non-overlapping Sub-arrays Each With Target Sum
1 parent 374bdf6 commit ad956dd

File tree

6 files changed

+303
-2
lines changed

6 files changed

+303
-2
lines changed

‎solution/1400-1499/1477.Find Two Non-overlapping Sub-arrays Each With Target Sum/README.md

Lines changed: 112 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -63,22 +63,133 @@
6363

6464
<!-- 这里可写通用的实现逻辑 -->
6565

66+
**方法一：哈希表 + 前缀和 + 动态规划**
67+
68+
我们可以使用哈希表 $d$ 记录前缀和最近一次出现的位置，初始时 $d[0]=0$。
69+
70+
定义 $f[i]$ 表示前 $i$ 个元素中，长度和为 $target$ 的最短子数组的长度。初始时 $f[0]=inf$。
71+
72+
遍历数组 `arr`，对于当前位置 $i$，计算前缀和 $s$，如果 $s-target$ 在哈希表中，记 $j=d[s-target]$，则 $f[i]=min(f[i],i-j)$，答案为 $ans=min(ans,f[j]+i-j)$。继续遍历下个位置。
73+
74+
最后，如果答案大于数组长度，则返回 $-1$，否则返回答案。
75+
76+
时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组长度。
77+
6678
<!-- tabs:start -->
6779

6880
### **Python3**
6981

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

7284
```python
73-
85+
class Solution:
86+
def minSumOfLengths(self, arr: List[int], target: int) -> int:
87+
d = {0: 0}
88+
s, n = 0, len(arr)
89+
f = [inf] * (n + 1)
90+
ans = inf
91+
for i, v in enumerate(arr, 1):
92+
s += v
93+
f[i] = f[i - 1]
94+
if s - target in d:
95+
j = d[s - target]
96+
f[i] = min(f[i], i - j)
97+
ans = min(ans, f[j] + i - j)
98+
d[s] = i
99+
return -1 if ans > n else ans
74100
```
75101

76102
### **Java**
77103

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

80106
```java
107+
class Solution {
108+
public int minSumOfLengths(int[] arr, int target) {
109+
Map<Integer, Integer> d = new HashMap<>();
110+
d.put(0, 0);
111+
int n = arr.length;
112+
int[] f = new int[n + 1];
113+
final int inf = 1 << 30;
114+
f[0] = inf;
115+
int s = 0, ans = inf;
116+
for (int i = 1; i <= n; ++i) {
117+
int v = arr[i - 1];
118+
s += v;
119+
f[i] = f[i - 1];
120+
if (d.containsKey(s - target)) {
121+
int j = d.get(s - target);
122+
f[i] = Math.min(f[i], i - j);
123+
ans = Math.min(ans, f[j] + i - j);
124+
}
125+
d.put(s, i);
126+
}
127+
return ans > n ? -1 : ans;
128+
}
129+
}
130+
```
131+
132+
### **C++**
133+
134+
```cpp
135+
class Solution {
136+
public:
137+
int minSumOfLengths(vector<int>& arr, int target) {
138+
unordered_map<int, int> d;
139+
d[0] = 0;
140+
int s = 0, n = arr.size();
141+
int f[n + 1];
142+
const int inf = 1 << 30;
143+
f[0] = inf;
144+
int ans = inf;
145+
for (int i = 1; i <= n; ++i) {
146+
int v = arr[i - 1];
147+
s += v;
148+
f[i] = f[i - 1];
149+
if (d.count(s - target)) {
150+
int j = d[s - target];
151+
f[i] = min(f[i], i - j);
152+
ans = min(ans, f[j] + i - j);
153+
}
154+
d[s] = i;
155+
}
156+
return ans > n ? -1 : ans;
157+
}
158+
};
159+
```
81160
161+
### **Go**
162+
163+
```go
164+
func minSumOfLengths(arr []int, target int) int {
165+
d := map[int]int{0: 0}
166+
const inf = 1 << 30
167+
s, n := 0, len(arr)
168+
f := make([]int, n+1)
169+
f[0] = inf
170+
ans := inf
171+
for i, v := range arr {
172+
i++
173+
f[i] = f[i-1]
174+
s += v
175+
if j, ok := d[s-target]; ok {
176+
f[i] = min(f[i], i-j)
177+
ans = min(ans, f[j]+i-j)
178+
}
179+
d[s] = i
180+
}
181+
if ans > n {
182+
return -1
183+
}
184+
return ans
185+
}
186+
187+
func min(a, b int) int {
188+
if a < b {
189+
return a
190+
}
191+
return b
192+
}
82193
```
83194

84195
### **...**

‎solution/1400-1499/1477.Find Two Non-overlapping Sub-arrays Each With Target Sum/README_EN.md

Lines changed: 100 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -51,13 +51,112 @@
5151
### **Python3**
5252

5353
```python
54-
54+
class Solution:
55+
def minSumOfLengths(self, arr: List[int], target: int) -> int:
56+
d = {0: 0}
57+
s, n = 0, len(arr)
58+
f = [inf] * (n + 1)
59+
ans = inf
60+
for i, v in enumerate(arr, 1):
61+
s += v
62+
f[i] = f[i - 1]
63+
if s - target in d:
64+
j = d[s - target]
65+
f[i] = min(f[i], i - j)
66+
ans = min(ans, f[j] + i - j)
67+
d[s] = i
68+
return -1 if ans > n else ans
5569
```
5670

5771
### **Java**
5872

5973
```java
74+
class Solution {
75+
public int minSumOfLengths(int[] arr, int target) {
76+
Map<Integer, Integer> d = new HashMap<>();
77+
d.put(0, 0);
78+
int n = arr.length;
79+
int[] f = new int[n + 1];
80+
final int inf = 1 << 30;
81+
f[0] = inf;
82+
int s = 0, ans = inf;
83+
for (int i = 1; i <= n; ++i) {
84+
int v = arr[i - 1];
85+
s += v;
86+
f[i] = f[i - 1];
87+
if (d.containsKey(s - target)) {
88+
int j = d.get(s - target);
89+
f[i] = Math.min(f[i], i - j);
90+
ans = Math.min(ans, f[j] + i - j);
91+
}
92+
d.put(s, i);
93+
}
94+
return ans > n ? -1 : ans;
95+
}
96+
}
97+
```
98+
99+
### **C++**
100+
101+
```cpp
102+
class Solution {
103+
public:
104+
int minSumOfLengths(vector<int>& arr, int target) {
105+
unordered_map<int, int> d;
106+
d[0] = 0;
107+
int s = 0, n = arr.size();
108+
int f[n + 1];
109+
const int inf = 1 << 30;
110+
f[0] = inf;
111+
int ans = inf;
112+
for (int i = 1; i <= n; ++i) {
113+
int v = arr[i - 1];
114+
s += v;
115+
f[i] = f[i - 1];
116+
if (d.count(s - target)) {
117+
int j = d[s - target];
118+
f[i] = min(f[i], i - j);
119+
ans = min(ans, f[j] + i - j);
120+
}
121+
d[s] = i;
122+
}
123+
return ans > n ? -1 : ans;
124+
}
125+
};
126+
```
60127
128+
### **Go**
129+
130+
```go
131+
func minSumOfLengths(arr []int, target int) int {
132+
d := map[int]int{0: 0}
133+
const inf = 1 << 30
134+
s, n := 0, len(arr)
135+
f := make([]int, n+1)
136+
f[0] = inf
137+
ans := inf
138+
for i, v := range arr {
139+
i++
140+
f[i] = f[i-1]
141+
s += v
142+
if j, ok := d[s-target]; ok {
143+
f[i] = min(f[i], i-j)
144+
ans = min(ans, f[j]+i-j)
145+
}
146+
d[s] = i
147+
}
148+
if ans > n {
149+
return -1
150+
}
151+
return ans
152+
}
153+
154+
func min(a, b int) int {
155+
if a < b {
156+
return a
157+
}
158+
return b
159+
}
61160
```
62161

63162
### **...**

‎solution/1400-1499/1477.Find Two Non-overlapping Sub-arrays Each With Target Sum/Solution.cpp

Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
class Solution {
2+
public:
3+
int minSumOfLengths(vector<int>& arr, int target) {
4+
unordered_map<int, int> d;
5+
d[0] = 0;
6+
int s = 0, n = arr.size();
7+
int f[n + 1];
8+
const int inf = 1 << 30;
9+
f[0] = inf;
10+
int ans = inf;
11+
for (int i = 1; i <= n; ++i) {
12+
int v = arr[i - 1];
13+
s += v;
14+
f[i] = f[i - 1];
15+
if (d.count(s - target)) {
16+
int j = d[s - target];
17+
f[i] = min(f[i], i - j);
18+
ans = min(ans, f[j] + i - j);
19+
}
20+
d[s] = i;
21+
}
22+
return ans > n ? -1 : ans;
23+
}
24+
};

‎solution/1400-1499/1477.Find Two Non-overlapping Sub-arrays Each With Target Sum/Solution.go

Lines changed: 29 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,29 @@
1+
func minSumOfLengths(arr []int, target int) int {
2+
d := map[int]int{0: 0}
3+
const inf = 1 << 30
4+
s, n := 0, len(arr)
5+
f := make([]int, n+1)
6+
f[0] = inf
7+
ans := inf
8+
for i, v := range arr {
9+
i++
10+
f[i] = f[i-1]
11+
s += v
12+
if j, ok := d[s-target]; ok {
13+
f[i] = min(f[i], i-j)
14+
ans = min(ans, f[j]+i-j)
15+
}
16+
d[s] = i
17+
}
18+
if ans > n {
19+
return -1
20+
}
21+
return ans
22+
}
23+
24+
func min(a, b int) int {
25+
if a < b {
26+
return a
27+
}
28+
return b
29+
}

‎solution/1400-1499/1477.Find Two Non-overlapping Sub-arrays Each With Target Sum/Solution.java

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
class Solution {
2+
public int minSumOfLengths(int[] arr, int target) {
3+
Map<Integer, Integer> d = new HashMap<>();
4+
d.put(0, 0);
5+
int n = arr.length;
6+
int[] f = new int[n + 1];
7+
final int inf = 1 << 30;
8+
f[0] = inf;
9+
int s = 0, ans = inf;
10+
for (int i = 1; i <= n; ++i) {
11+
int v = arr[i - 1];
12+
s += v;
13+
f[i] = f[i - 1];
14+
if (d.containsKey(s - target)) {
15+
int j = d.get(s - target);
16+
f[i] = Math.min(f[i], i - j);
17+
ans = Math.min(ans, f[j] + i - j);
18+
}
19+
d.put(s, i);
20+
}
21+
return ans > n ? -1 : ans;
22+
}
23+
}

‎solution/1400-1499/1477.Find Two Non-overlapping Sub-arrays Each With Target Sum/Solution.py

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
class Solution:
2+
def minSumOfLengths(self, arr: List[int], target: int) -> int:
3+
d = {0: 0}
4+
s, n = 0, len(arr)
5+
f = [inf] * (n + 1)
6+
ans = inf
7+
for i, v in enumerate(arr, 1):
8+
s += v
9+
f[i] = f[i - 1]
10+
if s - target in d:
11+
j = d[s - target]
12+
f[i] = min(f[i], i - j)
13+
ans = min(ans, f[j] + i - j)
14+
d[s] = i
15+
return -1 if ans > n else ans

0 commit comments

Comments
 (0)