Update 0494.目标和.md

problems/0494.目标和.md

@@ -293,19 +293,84 @@ class Solution {
 ```
 
 ### Python
+回溯版
+```python
+class Solution:
+
+
+    def backtracking(self, candidates, target, total, startIndex, path, result):
+        if total == target:
+            result.append(path[:])  # 将当前路径的副本添加到结果中
+        # 如果 sum + candidates[i] > target，则停止遍历
+        for i in range(startIndex, len(candidates)):
+            if total + candidates[i] > target:
+                break
+            total += candidates[i]
+            path.append(candidates[i])
+            self.backtracking(candidates, target, total, i + 1, path, result)
+            total -= candidates[i]
+            path.pop()
+
+    def findTargetSumWays(self, nums: List[int], target: int) -> int:
+        total = sum(nums)
+        if target > total:
+            return 0  # 此时没有方案
+        if (target + total) % 2 != 0:
+            return 0  # 此时没有方案，两个整数相加时要注意数值溢出的问题
+        bagSize = (target + total) // 2  # 转化为组合总和问题，bagSize就是目标和
+
+        # 以下是回溯法代码
+        result = []
+        nums.sort()  # 需要对nums进行排序
+        self.backtracking(nums, bagSize, 0, 0, [], result)
+        return len(result)
+
+```
+二维DP
 ```python
 class Solution:
     def findTargetSumWays(self, nums: List[int], target: int) -> int:
-        sumValue = sum(nums)
+        total_sum = sum(nums)  # 计算nums的总和
-        #注意边界条件为 target>sumValue or target<-sumValue or  (sumValue + target) % 2 == 1
+        if abs(target) > total_sum:
-        if abs(target) > sumValue or (sumValue + target) % 2 == 1: return 0
+            return 0  # 此时没有方案
-        bagSize = (sumValue + target) // 2
+        if (target + total_sum) % 2 == 1:
-        dp = [0] * (bagSize + 1)
+            return 0  # 此时没有方案
-        dp[0] = 1
+        target_sum = (target + total_sum) // 2  # 目标和
-        for i in range(len(nums)):
+
-            for j in range(bagSize, nums[i] - 1, -1):
+        # 创建二维动态规划数组，行表示选取的元素数量，列表示累加和
-                dp[j] += dp[j - nums[i]]
+        dp = [[0] * (target_sum + 1) for _ in range(len(nums) + 1)]
-        return dp[bagSize]
+
+        # 初始化状态
+        dp[0][0] = 1
+
+        # 动态规划过程
+        for i in range(1, len(nums) + 1):
+            for j in range(target_sum + 1):
+                dp[i][j] = dp[i - 1][j]  # 不选取当前元素
+                if j >= nums[i - 1]:
+                    dp[i][j] += dp[i - 1][j - nums[i - 1]]  # 选取当前元素
+
+        return dp[len(nums)][target_sum]  # 返回达到目标和的方案数
+
+
+```
+一维DP
+```python
+class Solution:
+    def findTargetSumWays(self, nums: List[int], target: int) -> int:
+        total_sum = sum(nums)  # 计算nums的总和
+        if abs(target) > total_sum:
+            return 0  # 此时没有方案
+        if (target + total_sum) % 2 == 1:
+            return 0  # 此时没有方案
+        target_sum = (target + total_sum) // 2  # 目标和
+        dp = [0] * (target_sum + 1)  # 创建动态规划数组，初始化为0
+        dp[0] = 1  # 当目标和为0时，只有一种方案，即什么都不选
+        for num in nums:
+            for j in range(target_sum, num - 1, -1):
+                dp[j] += dp[j - num]  # 状态转移方程，累加不同选择方式的数量
+        return dp[target_sum]  # 返回达到目标和的方案数
+
 ```
 
 ### Go