leetcode——第494题——目标和

题目：
给你一个整数数组 nums 和一个整数 target 。
向数组中的每个整数前添加 ‘+’ 或 ‘-’ ，然后串联起所有整数，可以构造一个 表达式 ：
例如，nums = [2, 1] ，可以在 2 之前添加 ‘+’ ，在 1 之前添加 ‘-’ ，然后串联起来得到表达式 “+2-1” 。
返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目

/*
分析：  式一：left - right = target;      式二： left + right = sum 
式一 与 式二 相加可得 式三：2*left = target + sum   
式三中 target 与 sum 都是已知且固定的，因此 left 可由此得出。

第一种解法：回溯法中的组合总和。
    时间复杂度都是是O(2^n)级别，所以最后超时了。
    为了加深自己的理解，自己写了一个版本，与 Carl的有差别，但是最后三个版本的都超时了

第二种解法：转换为 01背包问题
1、为什么是 01背包呢？
    因为数组中的每个值只能用一次。
2、与之前的不同，之前都是求容量为 j 的背包可以装的最大价值，
3、 时间复杂度O(n * m)，n为正数个数，m为背包容量
    空间复杂度：O(m) m为背包容量
4、本题中是求装满有几种方法，这其实还是回归的组合
    1、确定 dp 数组以及下标的含义
        dp[j] 表示容量为 j 的背包装满，有 dp[j] 种方法
    2、确定递推公式
        求组合类的问题都是类似于这种，其实就是把这些方法加起来就可以了。
        几乎所有的背包解决排列组合问题，都是用这个递推公式
        记住：在求装满背包有几种方法的情况下，递推公式就是这个：
        dp[j] = dp[j] + dp[j - nums[i]]
    3、dp 数组如何初始化
        dp[0] = 1，dp[j] 其他下标对应的数值应该初始化为 0。
        寓意为：装满容量为0的背包，有1种方法，就是装 0 件物品
        注意这里可不能把 dp[0]初始化为 0，这样会导致所有的递归结果都将是0，
    4、确定遍历顺序
        nums 放在外循环， target 放在内循环， 且内循环倒叙
        这个与之前的 01背包问题相似

*/

/***********************法一：版本一超时：回溯法—组合总和******************************/
// class Solution {
// private:
//     vector<int> result;     // 存储路径和
//     int count;  // 记录次数
//     // int path;
//     void backtracking(vector<int>& nums, int num, int startIndex, int path)
//     {
//         // 终止条件
//         if(path == num)
//         {
//             result.push_back(path);
//             count++;
//         }
//         // 出错一：for语句的终止条件，是两个
//         for(int i = startIndex; i < nums.size() && path + nums[i] <= num; i++)
//         {
//             path += nums[i];
//             cout << path;
//             // 出错二：递归函数传入的下标应该是 i+1 ，又错写成 startIndex+1
//             backtracking(nums, num, i + 1, path);
//             path -= nums[i];
//         }
//     }

// public:
//     int findTargetSumWays(vector<int>& nums, int target) 
//     {
//         result.clear();
//         count = 0;
//        // path = 0;

//         int sum = 0;
//         for(int i = 0; i < nums.size(); i++)
//         {
//             sum += nums[i];
//         }

//         if(sum < target)    return 0;   // 此时没有方案
//         if(((sum + target)) % 2)    return 0;   // 此时没有方案
//         // 满足以上两个条件，就转换为求 组合和的问题，两个int 相加的时候要小心溢出的问题
//         sort(nums.begin(),nums.end());
//         backtracking(nums, (target + sum)/2, 0, 0);
//         cout << endl;
//         return result.size();
//     }
// };
/***********************法一：版本二超时：回溯法—组合总和******************************/
// class Solution {
// private:
//     //vector<vector<int>> result;
//     // vector<int> path;
//     int count;
//     int path;
//     void backtracking(vector<int>& candidates, int target, int startIndex) {
//         if (path == target) {
//             // result.push_back(path);
//             count++;
//         }
//         // 如果 sum + candidates[i] > target 就终止遍历
//         for (int i = startIndex; i < candidates.size() && path + candidates[i] <= target; i++) {
//             path += candidates[i];
//             // path.push_back(candidates[i]);
//             cout << path;
//             backtracking(candidates, target, i + 1);
//             path -= candidates[i];
//             // path.pop_back();

//         }
//     }
// public:
//     int findTargetSumWays(vector<int>& nums, int S) {
//         int sum = 0;
//         for (int i = 0; i < nums.size(); i++) sum += nums[i];
//         if (S > sum) return 0; // 此时没有方案
//         if ((S + sum) % 2) return 0; // 此时没有方案，两个int相加的时候要各位小心数值溢出的问题
//         int bagSize = (S + sum) / 2; // 转变为组合总和问题，bagsize就是要求的和

//         // 以下为回溯法代码
//         // result.clear();
//         // path.clear();
//         count = 0;
//         path = 0;
//         sort(nums.begin(), nums.end()); // 需要排序
//         backtracking(nums, bagSize, 0);
//         cout << endl;
//         return count;
//     }
// };

/***********************法一：版本三不超时：回溯法—组合总和*****************************/
// class Solution {
// private:
//     vector<vector<int>> result;
//     vector<int> path;
//     int count;
//     void backtracking(vector<int>& candidates, int target, int sum, int startIndex) {
//         if (sum == target) {
//             // result.push_back(path);
//             count++;
//         }
//         // 如果 sum + candidates[i] > target 就终止遍历
//         for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) {
//             sum += candidates[i];
//             // path.push_back(candidates[i]);
//             cout << sum;
//             backtracking(candidates, target, sum, i + 1);
//             sum -= candidates[i];
//             // path.pop_back();

//         }
//     }
// public:
//     int findTargetSumWays(vector<int>& nums, int S) {
//         int sum = 0;
//         for (int i = 0; i < nums.size(); i++) sum += nums[i];
//         if (S > sum) return 0; // 此时没有方案
//         if ((S + sum) % 2) return 0; // 此时没有方案，两个int相加的时候要各位小心数值溢出的问题
//         int bagSize = (S + sum) / 2; // 转变为组合总和问题，bagsize就是要求的和

//         // 以下为回溯法代码
//         result.clear();
//         path.clear();
//         count = 0;
//         sort(nums.begin(), nums.end()); // 需要排序
//         backtracking(nums, bagSize, 0, 0);
//         cout << endl;
//         return count;
//     }
// };

/***************************法二：动态规划*********************************/
// 时间复杂度O(n * m)，n为正数个数，m为背包容量   空间复杂度：O(m) m为背包容量
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(sum < target)    return 0;
        if((sum + target) % 2 != 0) return 0;  
        // 这个等价于   if((sum + target) % 2 == 1) return 0;

        int bagSize = (sum + target) / 2;
        vector<int> dp(bagSize + 1, 0);

        dp[0] = 1;
        for(int i = 0; i < nums.size(); i++)
        {
            for(int j = bagSize; j >= nums[i]; j--)
            {
                dp[j] = dp[j] + dp[j - nums[i]];
            }
        } 
        return dp[bagSize];
    }
};