LeetCode 494. 目标和（C++）*

标签：动态规划、数组、回溯
思路一：用动态规划；
(sum−neg)−neg=sum−2⋅neg=target -->neg=(sum−target)/2
则该问题转化为 背包问题，即在数组中找能够组成neg的元素组合数
dp[i][j] 表示在数组nums的前i个数中选取元素，使得这些元素之和等于j的方案数。
dp[i][j]=dp[i−1][j], j<nums[i]
dp[i][j]=dp[i−1][j]+dp[i−1][j−nums[i]],j>nums[i]
思路二：回溯，每向下一层，都有两个分支：‘-’或’+‘

1.题目如下：

给你一个整数数组 nums 和一个整数 target 。

向数组中的每个整数前添加 ‘+’ 或 ‘-’ ，然后串联起所有整数，可以构造一个 表达式 ：

例如，nums = [2, 1] ，可以在 2 之前添加 ‘+’ ，在 1 之前添加 ‘-’ ，然后串联起来得到表达式 “+2-1” 。
返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目。

示例 1：

输入：nums = [1,1,1,1,1], target = 3
输出：5

解释：一共有 5 种方法让最终目标和为 3 。
-1 + 1 + 1 + 1 + 1 = 3
+1 - 1 + 1 + 1 + 1 = 3
+1 + 1 - 1 + 1 + 1 = 3
+1 + 1 + 1 - 1 + 1 = 3
+1 + 1 + 1 + 1 - 1 = 3

示例 2：

输入：nums = [1], target = 1
输出：1

提示：

1 <= nums.length <= 20
0 <= nums[i] <= 1000
0 <= sum(nums[i]) <= 1000
-1000 <= target <= 1000

2.代码如下：

class Solution {
public:

//思路一：动态规划
/*
    (sum−neg)−neg=sum−2⋅neg=target -->neg=(sum−target)/2
    则该问题转化为 背包问题，即在数组中找能够组成neg的元素组合数
    dp[i][j] 表示在数组nums的前i个数中选取元素，使得这些元素之和等于j的方案数。
    dp[i][j]=dp[i−1][j], j<nums[i]
    dp[i][j]=dp[i−1][j]+dp[i−1][j−nums[i]],j>nums[i]
*/
/*
    int findTargetSumWays(vector<int>& nums, int target) {
        int sum=0;
        for(int& num:nums) {
            sum+=num;
        }
        //如果无法整除，则不满足条件
        int diff=sum-target;
        if (diff<0 || diff%2!=0) {
            return 0;
        }
        //目标是在数字中添加负号，使得我们的负号数总和为neg
        int n=nums.size(),neg=diff/2;
        vector<vector<int>> dp(n+1, vector<int>(neg+1));
        dp[0][0] = 1;
        for (int i = 1; i <= n; i++) {
            int num=nums[i-1];
            for (int j = 0; j <= neg; j++) {
                dp[i][j]=dp[i-1][j];
                if (j>=num) {
                    dp[i][j]+=dp[i-1][j-num];
                }
            }
        }
        return dp[n][neg];
    }
*/
//思路二：回溯
/*
    深度遍历，每次向下有两个分支，添负号或正号
*/
    
    int findTargetSumWays(vector<int>& nums, int target) {
        int count = 0;
        backtrack(nums, target, 0, 0,count);
        return count;

    }

    void backtrack(vector<int>& nums, int target, int index, int sum,int &count) {
        if (index == nums.size()) {
            if (sum == target) {
                count++;
            }

        } 
        else {
            backtrack(nums, target, index+1,sum+nums[index],count);
            backtrack(nums, target, index+1,sum-nums[index],count);
        }
    }

};