Leetcode：494. 目标和（C++）

目录

问题描述：

实现代码与解析：

回溯：

原理思路：

动态规划：

原理思路：

---

问题描述：

        给你一个整数数组 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

实现代码与解析：

回溯：

class Solution {
public:
    int result = 0;//结果
    void backtracking(vector<int>& nums, int target, int startIndex, int sum)
    {
        if(startIndex == nums.size())
        {
            if(sum == target)
            {
                result++;
            }           
        }
        else
        {
            backtracking(nums, target, startIndex + 1, sum + nums[startIndex]);          
            backtracking(nums, target, startIndex + 1, sum - nums[startIndex]);           
        }   
        return;
    }
    int findTargetSumWays(vector<int>& nums, int target) 
    {
        backtracking(nums, target, 0, 0);
        return result;
    }
};

原理思路：

        回溯算法，这里每一个数组值都要用到，所以一定是从以第一数开始递归，就不用像一般回溯题里的for循环了，其实这里更像一个 dfs ，当然 dfs 和回溯的本质也没什么区别，就是对于数的两种选择而已，正和负，看作一个二叉树来遍历就可以。

        注意用引用来传入数组啊，不然会超时。

动态规划：

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) 
    {
        int sum = 0;
        //求和
        for(int i = 0; i < nums.size(); i++)
        {
            sum += nums[i];
        }
        if (abs(target) > sum || (target + sum) % 2 == 1) return 0; //没有方案
        int bag = (sum + target) / 2;

        vector<int> dp(bag + 1, 0);// 背包
        dp[0] = 1;
        // 背包遍历，一维
        for(int i = 0; i < nums.size(); i++)
        {
            for(int j = bag; j >= nums[i]; j--)
            {
                dp[j] += dp[j - nums[i]];
            }
        }
        return dp[bag];
    }
};

原理思路：

        根据题意，我们记 sum 为数组总和，neg 为负号的值，sum - neg 就为正号的值，所以我们可以推出公式(sum - neg) - neg = target，也就是：

         neg = （sum - target）/ 2，这个是求的负号的值，不过这里我们用的是正号值（sum + target）/ 2，解除来的结果肯定是一样的，target 大于 sum，或则 target 与 sum一个奇，一个偶，显然是没有方法的，返回 0。    

        可以先用二维写（主要代码）：

vector<vector<int>> dp(n + 1, vector<int>(neg + 1));
dp[0][0] = 1;
for (int i = 0; i <= n; i++) 
{
    int num = nums[i];
    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];
        }
    }
}

        dp数组的含义是在【0~i】物品选取，大小为 j 的背包装满有多少种方法，如果装不下编号为 i 的物品，其方法显然还是dp[i - 1][j]的方法个数，若可以装下，那么dp[i][j]就为所有dp[i - 1][ j - nums[i]]的和，这里是最不好理解的地方，首先是为什么不是dp[i - 1][j - num]加一，因为其实是乘一被隐藏了，就比如一个条路再延长铺一条路，它还是一条路，并不是相加关系，然后就是为什么是 += ，因为我们要考虑到所有情况，再次注意dp数组的含义，我们要把所有[j - nums[i]]的情况加上，才为dp[i][j]的值，其实还是不太好理解的。

        也可以优化成一维滚动数组，dp数组的含义是大小为 j 的背包装满有多少种方法，和二维的相比就是去掉了一个维度，然后遍历循序改变而已，其他不变。可以看看我前面写的文章。

动态规划：0-1背包问题 | 详细原理解释 | 代码及优化（C++）_Cosmoshhhyyy的博客-CSDN博客