0动态规划中等 01背包 leetcode494. 目标和

暴力解法

class Solution {
    public int findTargetSumWays(int[] nums, int S) {
        return process(0,nums,S);
    }

    public int process(int step, int[] nums, int target){
        if(step == nums.length){
            if(target == 0){
                return 1;
            }
            else{
                return 0;
            }
        }

        return process(step+1, nums, target-nums[step])
              +process(step+1, nums, target+nums[step]);
    }
}

二维数组的动态规划

二维数组的解法容易理解，想得通
给数组分配正负号刚好凑出S，然后分为两组，一组全为正用a表示，一组全为负用b表示，
所以可得：sum(a)-sum(b)=S
同时a,b的绝对值的和为原始数组的和即：sum(a)+sum(b)=sum(nums)
由此可得：
sum(a)=(sum(nums)+S)/2
用target 表示(sum(nums)+S)/2
所以题目可以转换为数组nums中和是target的子集的个数，即子集和问题

子集和问题的二维数组的动态规划解法

建立二维数组，nums数组的长度为行数，target+1为列数
状态定义：dp[i][j] 表示nums数组下标是0~i的数凑出和是j的个数
状态转移方程：dp[i][j] = dp[i-1][j] + dp[i-1][j-nums[i]]
初始值：dp[0][0] = 1;  dp[0][nums[0]] = 1;

dp[i][j] 有两种情况：1.nums[i]前面的数就凑出了j,即dp[i-1][j]；
2.加上nums[i]凑出了j，说明nums[i]前面的数凑出了j-nums[j],即dp[i-1][j-nums[i]]。
为什么dp[0][0] = 1 ？
当j - nums[i] == 0 成立的时候，根据上面分析，就说明单独的 nums[i] 这个数就恰好能够凑得j，dp[i][j]应该加一。
为了免去判断j - nums[i] == 0，令dp[0][0] = 1 可以实现单独能够凑得j的nums[i]加一的效果。
也就是说dp[i-1][j-nums[i]]包含了两种情况：1.单独的 nums[i] 这个数就恰好能够凑得j。2.nums[i]之前的数加上nums[i]凑出了j。
为什么dp[0][nums[0]] = 1？
给 dp[0][nums[0]] 赋初值是因为dp[i-1][j-nums[i]]若i从0开始，dp[i-1]会越界

本题不推荐二维数组的解法，因为要考虑dp[0][0]与dp[0][nums[0]]重叠了，很麻烦。

class Solution {
    public int findTargetSumWays(int[] nums, int S) {
       int sum = 0;
       for(int num : nums){
           sum += num;
       }
       if(((S + sum) & 1) == 1){
           return 0;
       }
       if(sum < S){
           return 0;
       }
       int target = (S + sum)/2;
       int[][] dp = new int[nums.length][target+1];
       dp[0][0] = 1;//给dp[0][0]赋初值，这样下面循环中省去了nums[i]==j的判断了
       if(nums[0] <= target){//给第1行赋初值
           dp[0][nums[0]] = 1;
           if(nums[0] == 0){//dp[0][0]与dp[0][nums[0]]重叠了，应该分别加一
               dp[0][nums[0]] = 2;
           }
       }
       for(int i = 1; i < nums.length; i++){
           for(int j = 0; j <= target; j++){
               dp[i][j] = dp[i-1][j];//nums[0]~nums[i]能否凑出j,首先继承nums[0]~nums[i-1]的结果
               if(j >= nums[i]){//在凑j时，nums[i]能够参与，则考虑nums[0]~nums[i-1]能否凑出j-nums[i]。
                   dp[i][j] += dp[i-1][j-nums[i]];
               }
           }
       }
       return dp[nums.length-1][target];
    }
}

一维数组的动态规划

推荐这种解法

子集和问题动态规划上文已解释，下面主要是与二位动态规划区别
二维数组每次都要继承上一层计算的结果（dp[i][j] = dp[i-1][j]），这样不如直接建立一维数组在上一步的基础上直接增加新的可能次数（dp[j] += dp[j-nums[i]]），不用再去继承了

注意内层循环是有后向前遍历，（我加上j >= nums[i]的判断条件，由前向后遍历行不通，谁成功了，教教我）

class Solution {
    public int findTargetSumWays(int[] nums, int S) {
       int sum = 0;
       for(int num : nums){
           sum += num;
       }
       if(sum < S || ((sum + S) & 1) == 1){
           return 0;
       }
       int target = (sum + S)/2;
       int[] dp = new int [target+1];
       dp[0] = 1;
       for(int i = 0; i < nums.length; i++){
           for(int j = target; j >= nums[i]; j--){
               dp[j] += dp[j-nums[i]];
           }
       }
       return dp[target];
    }
}