feat: add solutions to lc problem: No.0494

No.0494.Target Sum

Author: yanglbme

README.md

@@ -77,6 +77,7 @@
 -   [最长公共子序列](/solution/1100-1199/1143.Longest%20Common%20Subsequence/README.md) - 线性 DP、最长公共子序列模型
 -   [两个字符串的最小 ASCII 删除和](/solution/0700-0799/0712.Minimum%20ASCII%20Delete%20Sum%20for%20Two%20Strings/README.md) - 线性 DP、最长公共子序列模型
 -   [两个字符串的删除操作](/solution/0500-0599/0583.Delete%20Operation%20for%20Two%20Strings/README.md) - 线性 DP、最长公共子序列模型
+-   [目标和](/solution/0400-0499/0494.Target%20Sum/README.md) - 0-1 背包问题
 <!-- 背包问题、状态机模型、状压DP、区间DP、树形DP、数位DP 待补充 -->
 
 ### 4. 高级数据结构

README_EN.md

@@ -74,6 +74,7 @@ Complete solutions to [LeetCode](https://leetcode.com/problemset/all/), [LCOF](h
 -   [Longest Common Subsequence](/solution/1100-1199/1143.Longest%20Common%20Subsequence/README_EN.md) - Linear problem, LCS
 -   [Minimum ASCII Delete Sum for Two Strings](/solution/0700-0799/0712.Minimum%20ASCII%20Delete%20Sum%20for%20Two%20Strings/README_EN.md) - Linear problem, LCS
 -   [Delete Operation for Two Strings](/solution/0500-0599/0583.Delete%20Operation%20for%20Two%20Strings/README_EN.md) - Linear problem, LCS
+-   [Target Sum](/solution/0400-0499/0494.Target%20Sum/README_EN.md) - 0-1 Knapsack
 
 ### 4. Advanced Data Structures
 

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

@@ -53,72 +53,55 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-题目可以转换为 `0-1` 背包问题，只不过下标可能会出现负数，需要特殊处理。
+**方法一：动态规划**
 
-也可以用 DFS 记忆化搜索。
+题目可以转换为 `0-1` 背包问题。
 
-<!-- tabs:start -->
+设整数数组总和为 `s`，添加 `-` 号的元素之和为 `x`，则添加 `+` 号的元素之和为 `s - x`，那么 `s - x - x = target`，`2x = s - target`。左式成立需要满足 `s - target` 一定大于等于 0，并且能够被 2 整除。在此前提下，我们可以将问题抽象为： 从数组中选出若干个数，使得选出的元素之和为 x。显然这是一个 `0-1` 背包问题。
 
-### **Python3**
+定义 `dp[i][j]` 表示从前 i 个数中选出若干个数，使得所选元素之和为 j 的所有方案数。
 
-**0-1 背包**
+<!-- tabs:start -->
 
-```python
-class Solution:
-    def findTargetSumWays(self, nums: List[int], target: int) -> int:
-        if target < -1000 or target > 1000:
-            return 0
-        n = len(nums)
-        dp = [[0] * 2001 for i in range(n)]
-        dp[0][nums[0] + 1000] += 1
-        dp[0][-nums[0] + 1000] += 1
-        for i in range(1, n):
-            for j in range(-1000, 1001):
-                if dp[i - 1][j + 1000] > 0:
-                    dp[i][j + nums[i] + 1000] += dp[i - 1][j + 1000]
-                    dp[i][j - nums[i] + 1000] += dp[i - 1][j + 1000]
-        return dp[n - 1][target + 1000]
-```
+### **Python3**
 
-设：添加 `-` 号的元素之和为 `x`，则添加 `+` 号的元素之和为 `s - x`，`s - x - x = target`，`2x = s - target`。需要满足 `s - target` 一定大于等于 0，并且能够被 2 整除。
+动态规划——`0-1` 背包朴素做法：
 
 ```python
 class Solution:
     def findTargetSumWays(self, nums: List[int], target: int) -> int:
         s = sum(nums)
-        if s - target < 0 or (s - target) % 2 != 0:
+        if s < target or (s - target) % 2 != 0:
             return 0
-        target = (s - target) // 2 + 1
-        n = len(nums) + 1
-        dp = [[0] * target for _ in range(n)]
+        m, n = len(nums) + 1, (s - target) // 2 + 1
+        dp = [[0] * n for _ in range(m)]
         dp[0][0] = 1
-        for i in range(1, n):
-            for j in range(target):
+        for i in range(1, m):
+            for j in range(n):
                 dp[i][j] = dp[i - 1][j]
                 if nums[i - 1] <= j:
                     dp[i][j] += dp[i - 1][j - nums[i - 1]]
         return dp[-1][-1]
 ```
 
-空间优化：
+动态规划——`0-1` 背包空间优化：
 
 ```python
 class Solution:
     def findTargetSumWays(self, nums: List[int], target: int) -> int:
         s = sum(nums)
-        if s - target < 0 or (s - target) % 2 != 0:
+        if s < target or (s - target) % 2 != 0:
             return 0
-        target = (s - target) // 2 + 1
-        n = len(nums) + 1
-        dp = [0] * target
+        m, n = len(nums) + 1, (s - target) // 2 + 1
+        dp = [0] * n
         dp[0] = 1
-        for i in range(1, n):
-            for j in range(target - 1, nums[i - 1] - 1, -1):
+        for i in range(1, m):
+            for j in range(n - 1, nums[i - 1] - 1, -1):
                 dp[j] += dp[j - nums[i - 1]]
         return dp[-1]
 ```
 
-**DFS**
+DFS：
 
 ```python
 class Solution:
@@ -142,131 +125,180 @@ class Solution:
 ```java
 class Solution {
     public int findTargetSumWays(int[] nums, int target) {
-        if (target < -1000 || target > 1000) {
+        int s = 0;
+        for (int v : nums) {
+            s += v;
+        }
+        if (s < target || (s - target) % 2 != 0) {
             return 0;
         }
-
-        int n = nums.length;
-        int[][] dp = new int[n][2001];
-
-        dp[0][nums[0] + 1000] += 1;
-        dp[0][-nums[0] + 1000] += 1;
-
-        for (int i = 1; i < n; i++) {
-            for (int j = -1000; j <= 1000; j++) {
-                if (dp[i - 1][j + 1000] > 0) {
-                    dp[i][j + nums[i] + 1000] += dp[i - 1][j + 1000];
-                    dp[i][j - nums[i] + 1000] += dp[i - 1][j + 1000];
+        int m = nums.length;
+        int n = (s - target) / 2;
+        int[][] dp = new int[m + 1][n + 1];
+        dp[0][0] = 1;
+        for (int i = 1; i <= m; ++i) {
+            for (int j = 0; j <= n; ++j) {
+                dp[i][j] = dp[i - 1][j];
+                if (nums[i - 1] <= j) {
+                    dp[i][j] += dp[i - 1][j - nums[i - 1]];
                 }
             }
         }
-        return dp[n - 1][target + 1000];
+        return dp[m][n];
     }
 }
 ```
 
-空间优化：
-
 ```java
 class Solution {
     public int findTargetSumWays(int[] nums, int target) {
         int s = 0;
-        for (int x : nums) {
-            s += x;
+        for (int v : nums) {
+            s += v;
         }
-        if (s - target < 0 || (s - target) % 2 != 0) {
+        if (s < target || (s - target) % 2 != 0) {
             return 0;
         }
-        target = (s - target) / 2 + 1;
-        int[] dp = new int[target];
+        int m = nums.length;
+        int n = (s - target) / 2;
+        int[] dp = new int[n + 1];
         dp[0] = 1;
-        for (int i = 1; i < nums.length + 1; ++i) {
-            for (int j = target - 1; j >= nums[i - 1]; --j) {
+        for (int i = 1; i <= m; ++i) {
+            for (int j = n; j >= nums[i - 1]; --j) {
                 dp[j] += dp[j - nums[i - 1]];
             }
         }
-        return dp[target - 1];
+        return dp[n];
     }
 }
 ```
 
 ### **C++**
 
-空间优化：
+```cpp
+class Solution {
+public:
+    int findTargetSumWays(vector<int>& nums, int target) {
+        int s = 0;
+        for (int& v : nums) s += v;
+        if (s < target || (s - target) % 2 != 0) return 0;
+        int m = nums.size(), n = (s - target) / 2;
+        vector<vector<int>> dp(m + 1, vector<int>(n + 1));
+        dp[0][0] = 1;
+        for (int i = 1; i <= m; ++i)
+        {
+            for (int j = 0; j <= n; ++j)
+            {
+                dp[i][j] += dp[i - 1][j];
+                if (nums[i - 1] <= j) dp[i][j] += dp[i - 1][j - nums[i - 1]];
+            }
+        }
+        return dp[m][n];
+    }
+};
+```
 
 ```cpp
 class Solution {
 public:
     int findTargetSumWays(vector<int>& nums, int target) {
         int s = 0;
-        for (int x : nums) s += x;
-        if (s - target < 0 || (s - target) % 2 != 0) return 0;
-        target = (s - target) / 2 + 1;
-        vector<int> dp(target);
+        for (int& v : nums) s += v;
+        if (s < target || (s - target) % 2 != 0) return 0;
+        int m = nums.size(), n = (s - target) / 2;
+        vector<int> dp(n + 1);
         dp[0] = 1;
-        for (int i = 1; i < nums.size() + 1; ++i)
+        for (int i = 1; i <= m; ++i)
         {
-            for (int j = target - 1; j >= nums[i - 1]; --j)
+            for (int j = n; j >= nums[i - 1]; --j)
             {
                 dp[j] += dp[j - nums[i - 1]];
             }
         }
-        return dp[target - 1];
+        return dp[n];
     }
 };
 ```
 
 ### **Go**
 
-<!-- 这里可写当前语言的特殊实现逻辑 -->
-
 ```go
 func findTargetSumWays(nums []int, target int) int {
-	if target < -1000 || target > 1000 {
+	s := 0
+	for _, v := range nums {
+		s += v
+	}
+	if s < target || (s-target)%2 != 0 {
 		return 0
 	}
-	n := len(nums)
-	dp := make([][]int, n)
-	for i := 0; i < n; i++ {
-		dp[i] = make([]int, 2001)
+	m, n := len(nums), (s-target)/2
+	dp := make([][]int, m+1)
+	for i := range dp {
+		dp[i] = make([]int, n+1)
 	}
-	dp[0][nums[0]+1000] += 1
-	dp[0][-nums[0]+1000] += 1
-	for i := 1; i < n; i++ {
-		for j := -1000; j <= 1000; j++ {
-			if dp[i-1][j+1000] > 0 {
-				dp[i][j+nums[i]+1000] += dp[i-1][j+1000]
-				dp[i][j-nums[i]+1000] += dp[i-1][j+1000]
+	dp[0][0] = 1
+	for i := 1; i <= m; i++ {
+		for j := 0; j <= n; j++ {
+			dp[i][j] = dp[i-1][j]
+			if nums[i-1] <= j {
+				dp[i][j] += dp[i-1][j-nums[i-1]]
 			}
 		}
 	}
-	return dp[n-1][target+1000]
+	return dp[m][n]
 }
 ```
 
-空间优化：
-
 ```go
 func findTargetSumWays(nums []int, target int) int {
 	s := 0
-	for _, x := range nums {
-		s += x
+	for _, v := range nums {
+		s += v
 	}
-	if s-target < 0 || (s-target)%2 != 0 {
+	if s < target || (s-target)%2 != 0 {
 		return 0
 	}
-	target = (s-target)/2 + 1
-	dp := make([]int, target)
+	m, n := len(nums), (s-target)/2
+	dp := make([]int, n+1)
 	dp[0] = 1
-	for i := 1; i < len(nums)+1; i++ {
-		for j := target - 1; j >= nums[i-1]; j-- {
+	for i := 1; i <= m; i++ {
+		for j := n; j >= nums[i-1]; j-- {
 			dp[j] += dp[j-nums[i-1]]
 		}
 	}
-	return dp[target-1]
+	return dp[n]
 }
 ```
 
+### **JavaScript**
+
+```js
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+var findTargetSumWays = function (nums, target) {
+    let s = 0;
+    for (let v of nums) {
+        s += v;
+    }
+    if (s < target || (s - target) % 2 != 0) {
+        return 0;
+    }
+    const m = nums.length;
+    const n = (s - target) / 2;
+    let dp = new Array(n + 1).fill(0);
+    dp[0] = 1;
+    for (let i = 1; i <= m; ++i) {
+        for (let j = n; j >= nums[i - 1]; --j) {
+            dp[j] += dp[j - nums[i - 1]];
+        }
+    }
+    return dp[n];
+};
+```
+
 ### **...**
 
 ```