【LeetCode 494】Target Sum

题意：

给一个数组，里面的数字都是非负的，然后一个目标值，问如何安排它们的正负号可以使得数组之和正好为目标值。

思路：

递归，时间复杂度 O(2^n)。
动态规划，时间复杂度 O(n*sum)，空间复杂度O(n*sum)可以优化到O(sum)。
状态方程ways[i][j]表示前 i 个数字，计算得到 j 的方式。

动态规划的思路注意。

代码：

递归：

class Solution {
public:
    int ans = 0;
    
    int findTargetSumWays(vector<int>& nums, int S) {
        dfs(nums, S, 0, 0);
        return ans;
    }
    
    void dfs(vector<int>& nums, int S, int cur, int index) {
        if (index == nums.size() && cur == S) {
            ans++;
            return;
        }
        if (index == nums.size()) return;
        
        dfs(nums, S, cur+nums[index], index+1);
        dfs(nums, S, cur-nums[index], index+1);
    }
};

动态规划：

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int S) {
        int n = nums.size();
        int sum = 0;
        for (int i=0; i<n; ++i) {
            sum += nums[i];
        }
        if (sum < S) return 0;
        
        int offset = sum;
        vector<vector<int> > dp(n+1, vector<int>(sum+offset+1));
        
        dp[0][offset] = 1;
        for (int i=1; i<=n; ++i) {
            for (int j=0; j<=2*sum; ++j) {
                if (dp[i-1][j]) {
                    if (j >= nums[i-1]) dp[i][j-nums[i-1]] += dp[i-1][j];
                    if (j <= 2*sum-nums[i-1]) dp[i][j+nums[i-1]] += dp[i-1][j];
                }
            }
        }
        
        return dp[n][S+offset];
    }
};

##########################################################
第二次遇见。。。本来想写动态规划，写了半天，写了个递归。动态规划，因为有负数，一维的时候，状态转移总会受到影响。。。。。。结果。变成二维的就好了。。。555