LeetCode-目标和

这个题很容易能想到用DFS去做，只要将所有的累加情况列举出来，就能得到最终和为S的方案数

int count = 0;

    public int findTargetSumWays(int[] nums, int S) {
        find(0,nums,0,S);
        return count;
    }

    private void find(int index, int[] nums, int sum, int S){
        if (index == nums.length) {
            if (S == sum){
                count ++;
            }
        }else{
            find(index + 1, nums, sum + nums[index], S);
            find(index + 1, nums, sum - nums[index], S);
        }
    }

不难发现，递归过程中会有很多冗余计算，比如1 1 1 1 -1 和 1 1 1 1 1这两个组合的和，都是从头开始累加计算出来的，如果我们将1 1 1 1的结果保存下来，那么就能减少很多不必要的计算！

动态规划：（多做练习才能总结出状态转移方程）

动态规划的状态转移方程：

dp[i][j] = dp[i-1][j-nums[i]] + dp[i-1][j+nums[i]]

用数组中的前i个元素组成合为j的方案数

又因为数组下标不能为负，j的范围就是sum*2+1，加1是因为0

代码里注意分界

public int findTargetSumWays(int[] nums, int S) {
        int sum = 0;
        for (int c : nums){
            sum += c;
        }
        if (sum < S){
            return 0;
        }
        
        int dp[][] = new int[nums.length][sum*2+1];
        if (nums[0] == 0){
            dp[0][sum] = 2;
        }else{
            dp[0][sum - nums[0]] = 1;
            dp[0][sum + nums[0]] = 1;
        }
        
        for (int i = 1; i < nums.length; i++){
            for (int j = 0; j < sum*2+1; j++){
                int l = j + nums[i] < sum*2+1 ? j + nums[i] : 0;
                int r = j - nums[i] >=0 ? j - nums[i] : 0;
                dp[i][j] = dp[i-1][l] + dp[i-1][r];
            }
        }
        
        return dp[nums.length - 1][sum + S];
    }