Skip to content

Commit 40a6a04

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0494.Target Sum
1 parent 8fa590a commit 40a6a04

File tree

6 files changed

+269
-45
lines changed

6 files changed

+269
-45
lines changed

‎solution/0400-0499/0494.Target Sum/README.md

+113-2
Original file line numberDiff line numberDiff line change
@@ -37,12 +37,11 @@
3737
<li>保证返回的最终结果能被 32 位整数存下。</li>
3838
</ul>
3939

40-
4140
## 解法
4241

4342
<!-- 这里可写通用的实现逻辑 -->
4443

45-
类似背包问题，只不过下标可能会出现负数，需要特殊处理。
44+
题目可以转换为 `0-1` 背包问题，只不过下标可能会出现负数，需要特殊处理。
4645

4746
<!-- tabs:start -->
4847

@@ -65,6 +64,44 @@ class Solution:
6564
return dp[n - 1][target + 1000]
6665
```
6766

67+
设：添加 `-` 号的元素之和为 `x`，则添加 `+` 号的元素之和为 `s - x`，`s - x - x = target`，`2x = s - target`。需要满足 `s - target` 一定大于等于 0，并且能够被 2 整除。
68+
69+
```python
70+
class Solution:
71+
def findTargetSumWays(self, nums: List[int], target: int) -> int:
72+
s = sum(nums)
73+
if s - target < 0 or (s - target) % 2 != 0:
74+
return 0
75+
target = (s - target) // 2 + 1
76+
n = len(nums) + 1
77+
dp = [[0] * target for _ in range(n)]
78+
dp[0][0] = 1
79+
for i in range(1, n):
80+
for j in range(target):
81+
dp[i][j] = dp[i - 1][j]
82+
if nums[i - 1] <= j:
83+
dp[i][j] += dp[i - 1][j - nums[i - 1]]
84+
return dp[-1][-1]
85+
```
86+
87+
空间优化：
88+
89+
```python
90+
class Solution:
91+
def findTargetSumWays(self, nums: List[int], target: int) -> int:
92+
s = sum(nums)
93+
if s - target < 0 or (s - target) % 2 != 0:
94+
return 0
95+
target = (s - target) // 2 + 1
96+
n = len(nums) + 1
97+
dp = [0] * target
98+
dp[0] = 1
99+
for i in range(1, n):
100+
for j in range(target - 1, nums[i - 1] - 1, -1):
101+
dp[j] += dp[j - nums[i - 1]]
102+
return dp[-1]
103+
```
104+
68105
### **Java**
69106

70107
<!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -95,6 +132,57 @@ class Solution {
95132
}
96133
```
97134

135+
空间优化：
136+
137+
```java
138+
class Solution {
139+
public int findTargetSumWays(int[] nums, int target) {
140+
int s = 0;
141+
for (int x : nums) {
142+
s += x;
143+
}
144+
if (s - target < 0 || (s - target) % 2 != 0) {
145+
return 0;
146+
}
147+
target = (s - target) / 2 + 1;
148+
int[] dp = new int[target];
149+
dp[0] = 1;
150+
for (int i = 1; i < nums.length + 1; ++i) {
151+
for (int j = target - 1; j >= nums[i - 1]; --j) {
152+
dp[j] += dp[j - nums[i - 1]];
153+
}
154+
}
155+
return dp[target - 1];
156+
}
157+
}
158+
```
159+
160+
### **C++**
161+
162+
空间优化：
163+
164+
```cpp
165+
class Solution {
166+
public:
167+
int findTargetSumWays(vector<int>& nums, int target) {
168+
int s = 0;
169+
for (int x : nums) s += x;
170+
if (s - target < 0 || (s - target) % 2 != 0) return 0;
171+
target = (s - target) / 2 + 1;
172+
vector<int> dp(target);
173+
dp[0] = 1;
174+
for (int i = 1; i < nums.size() + 1; ++i)
175+
{
176+
for (int j = target - 1; j >= nums[i - 1]; --j)
177+
{
178+
dp[j] += dp[j - nums[i - 1]];
179+
}
180+
}
181+
return dp[target - 1];
182+
}
183+
};
184+
```
185+
98186
### **Go**
99187
100188
<!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -123,6 +211,29 @@ func findTargetSumWays(nums []int, target int) int {
123211
}
124212
```
125213

214+
空间优化：
215+
216+
```go
217+
func findTargetSumWays(nums []int, target int) int {
218+
s := 0
219+
for _, x := range nums {
220+
s += x
221+
}
222+
if s-target < 0 || (s-target)%2 != 0 {
223+
return 0
224+
}
225+
target = (s-target)/2 + 1
226+
dp := make([]int, target)
227+
dp[0] = 1
228+
for i := 1; i < len(nums)+1; i++ {
229+
for j := target - 1; j >= nums[i-1]; j-- {
230+
dp[j] += dp[j-nums[i-1]]
231+
}
232+
}
233+
return dp[target-1]
234+
}
235+
```
236+
126237
### **...**
127238

128239
```

‎solution/0400-0499/0494.Target Sum/README_EN.md

+102-1
Original file line numberDiff line numberDiff line change
@@ -45,7 +45,6 @@
4545
<li><code>-1000 &lt;= target &lt;= 1000</code></li>
4646
</ul>
4747

48-
4948
## Solutions
5049

5150
It is similar to the backpack problem, except that the index may appear negative, which requires special handling.
@@ -71,6 +70,40 @@ class Solution:
7170
return dp[n - 1][target + 1000]
7271
```
7372

73+
```python
74+
class Solution:
75+
def findTargetSumWays(self, nums: List[int], target: int) -> int:
76+
s = sum(nums)
77+
if s - target < 0 or (s - target) % 2 != 0:
78+
return 0
79+
target = (s - target) // 2 + 1
80+
n = len(nums) + 1
81+
dp = [[0] * target for _ in range(n)]
82+
dp[0][0] = 1
83+
for i in range(1, n):
84+
for j in range(target):
85+
dp[i][j] = dp[i - 1][j]
86+
if nums[i - 1] <= j:
87+
dp[i][j] += dp[i - 1][j - nums[i - 1]]
88+
return dp[-1][-1]
89+
```
90+
91+
```python
92+
class Solution:
93+
def findTargetSumWays(self, nums: List[int], target: int) -> int:
94+
s = sum(nums)
95+
if s - target < 0 or (s - target) % 2 != 0:
96+
return 0
97+
target = (s - target) // 2 + 1
98+
n = len(nums) + 1
99+
dp = [0] * target
100+
dp[0] = 1
101+
for i in range(1, n):
102+
for j in range(target - 1, nums[i - 1] - 1, -1):
103+
dp[j] += dp[j - nums[i - 1]]
104+
return dp[-1]
105+
```
106+
74107
### **Java**
75108

76109
```java
@@ -99,6 +132,53 @@ class Solution {
99132
}
100133
```
101134

135+
```java
136+
class Solution {
137+
public int findTargetSumWays(int[] nums, int target) {
138+
int s = 0;
139+
for (int x : nums) {
140+
s += x;
141+
}
142+
if (s - target < 0 || (s - target) % 2 != 0) {
143+
return 0;
144+
}
145+
target = (s - target) / 2 + 1;
146+
int[] dp = new int[target];
147+
dp[0] = 1;
148+
for (int i = 1; i < nums.length + 1; ++i) {
149+
for (int j = target - 1; j >= nums[i - 1]; --j) {
150+
dp[j] += dp[j - nums[i - 1]];
151+
}
152+
}
153+
return dp[target - 1];
154+
}
155+
}
156+
```
157+
158+
### **C++**
159+
160+
```cpp
161+
class Solution {
162+
public:
163+
int findTargetSumWays(vector<int>& nums, int target) {
164+
int s = 0;
165+
for (int x : nums) s += x;
166+
if (s - target < 0 || (s - target) % 2 != 0) return 0;
167+
target = (s - target) / 2 + 1;
168+
vector<int> dp(target);
169+
dp[0] = 1;
170+
for (int i = 1; i < nums.size() + 1; ++i)
171+
{
172+
for (int j = target - 1; j >= nums[i - 1]; --j)
173+
{
174+
dp[j] += dp[j - nums[i - 1]];
175+
}
176+
}
177+
return dp[target - 1];
178+
}
179+
};
180+
```
181+
102182
### **Go**
103183
104184
```go
@@ -125,6 +205,27 @@ func findTargetSumWays(nums []int, target int) int {
125205
}
126206
```
127207

208+
```go
209+
func findTargetSumWays(nums []int, target int) int {
210+
s := 0
211+
for _, x := range nums {
212+
s += x
213+
}
214+
if s-target < 0 || (s-target)%2 != 0 {
215+
return 0
216+
}
217+
target = (s-target)/2 + 1
218+
dp := make([]int, target)
219+
dp[0] = 1
220+
for i := 1; i < len(nums)+1; i++ {
221+
for j := target - 1; j >= nums[i-1]; j-- {
222+
dp[j] += dp[j-nums[i-1]]
223+
}
224+
}
225+
return dp[target-1]
226+
}
227+
```
228+
128229
### **...**
129230

130231
```

‎solution/0400-0499/0494.Target Sum/Solution.cpp

+19
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,19 @@
1+
class Solution {
2+
public:
3+
int findTargetSumWays(vector<int>& nums, int target) {
4+
int s = 0;
5+
for (int x : nums) s += x;
6+
if (s - target < 0 || (s - target) % 2 != 0) return 0;
7+
target = (s - target) / 2 + 1;
8+
vector<int> dp(target);
9+
dp[0] = 1;
10+
for (int i = 1; i < nums.size() + 1; ++i)
11+
{
12+
for (int j = target - 1; j >= nums[i - 1]; --j)
13+
{
14+
dp[j] += dp[j - nums[i - 1]];
15+
}
16+
}
17+
return dp[target - 1];
18+
}
19+
};

‎solution/0400-0499/0494.Target Sum/Solution.go

+13-16
Original file line numberDiff line numberDiff line change
@@ -1,21 +1,18 @@
11
func findTargetSumWays(nums []int, target int) int {
2-
if target < -1000 || target > 1000 {
3-
return 0
2+
s := 0
3+
for _, x := range nums {
4+
s += x
45
}
5-
n := len(nums)
6-
dp := make([][]int, n)
7-
for i := 0; i < n; i++ {
8-
dp[i] = make([]int, 2001)
6+
if s-target < 0 || (s-target)%2 != 0 {
7+
return 0
98
}
10-
dp[0][nums[0]+1000] += 1
11-
dp[0][-nums[0]+1000] += 1
12-
for i := 1; i < n; i++ {
13-
for j := -1000; j <= 1000; j++ {
14-
if dp[i-1][j+1000] > 0 {
15-
dp[i][j+nums[i]+1000] += dp[i-1][j+1000]
16-
dp[i][j-nums[i]+1000] += dp[i-1][j+1000]
17-
}
9+
target = (s-target)/2 + 1
10+
dp := make([]int, target)
11+
dp[0] = 1
12+
for i := 1; i < len(nums)+1; i++ {
13+
for j := target - 1; j >= nums[i-1]; j-- {
14+
dp[j] += dp[j-nums[i-1]]
1815
}
1916
}
20-
return dp[n-1][target+1000]
21-
}
17+
return dp[target-1]
18+
}

‎solution/0400-0499/0494.Target Sum/Solution.java

+13-16
Original file line numberDiff line numberDiff line change
@@ -1,23 +1,20 @@
11
class Solution {
22
public int findTargetSumWays(int[] nums, int target) {
3-
if (target < -1000 || target > 1000) {
3+
int s = 0;
4+
for (int x : nums) {
5+
s += x;
6+
}
7+
if (s - target < 0 || (s - target) % 2 != 0) {
48
return 0;
59
}
6-
7-
int n = nums.length;
8-
int[][] dp = new int[n][2001];
9-
10-
dp[0][nums[0] + 1000] += 1;
11-
dp[0][-nums[0] + 1000] += 1;
12-
13-
for (int i = 1; i < n; i++) {
14-
for (int j = -1000; j <= 1000; j++) {
15-
if (dp[i - 1][j + 1000] > 0) {
16-
dp[i][j + nums[i] + 1000] += dp[i - 1][j + 1000];
17-
dp[i][j - nums[i] + 1000] += dp[i - 1][j + 1000];
18-
}
10+
target = (s - target) / 2 + 1;
11+
int[] dp = new int[target];
12+
dp[0] = 1;
13+
for (int i = 1; i < nums.length + 1; ++i) {
14+
for (int j = target - 1; j >= nums[i - 1]; --j) {
15+
dp[j] += dp[j - nums[i - 1]];
1916
}
2017
}
21-
return dp[n - 1][target + 1000];
18+
return dp[target - 1];
2219
}
23-
}
20+
}

‎solution/0400-0499/0494.Target Sum/Solution.py

+9-10
Original file line numberDiff line numberDiff line change
@@ -1,14 +1,13 @@
11
class Solution:
22
def findTargetSumWays(self, nums: List[int], target: int) -> int:
3-
if target < -1000 or target > 1000:
3+
s = sum(nums)
4+
if s - target < 0 or (s - target) % 2 != 0:
45
return 0
5-
n = len(nums)
6-
dp = [[0] * 2001 for i in range(n)]
7-
dp[0][nums[0] + 1000] += 1
8-
dp[0][-nums[0] + 1000] += 1
6+
target = (s - target) // 2 + 1
7+
n = len(nums) + 1
8+
dp = [0] * target
9+
dp[0] = 1
910
for i in range(1, n):
10-
for j in range(-1000, 1001):
11-
if dp[i - 1][j + 1000] > 0:
12-
dp[i][j + nums[i] + 1000] += dp[i - 1][j + 1000]
13-
dp[i][j - nums[i] + 1000] += dp[i - 1][j + 1000]
14-
return dp[n - 1][target + 1000]
11+
for j in range(target - 1, nums[i - 1] - 1, -1):
12+
dp[j] += dp[j - nums[i - 1]]
13+
return dp[-1]

0 commit comments

Comments
 (0)