L494目标和

494. 目标和
     给定一个非负整数数组，a1, a2, …, an, 和一个目标数，S。现在你有两个符号 + 和 -。对于数组中的任意一个整数，你都可以从 + 或 -中选择一个符号添加在前面。

返回可以使最终数组和为目标数 S 的所有添加符号的方法数。

示例 1:

输入: nums: [1, 1, 1, 1, 1], S: 3
输出: 5
解释:

-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

一共有5种方法让最终目标和为3。
注意:

数组非空，且长度不会超过20。
初始的数组的和不会超过1000。
保证返回的最终结果能被32位整数存下。

1.利用dfs回溯方法，完成自由组合-（与招行4.8笔试那题差不多）s与sum重复了，可以使用一个变量，只需要边界处判断是否为0即可
这种不算是回溯，因为只有两种可能

class Solution {
    int res;
    public int findTargetSumWays(int[] nums, int s) {
        if(nums == null || nums.length == 0) return -1;
        res = 0;
        dfs(nums, 0, s, 0);
        return res;
    }

    void dfs(int[] nums, int index, int s, int sum){
        if(index == nums.length){
           if(sum == s){
               res++;
           }
           return;
        }
        sum += nums[index];
        dfs(nums, index + 1, s, sum);
        sum -= 2*nums[index];//临时还原一下状态
        dfs(nums, index + 1, s, sum);
    }

class Solution {
    int res;
    public int findTargetSumWays(int[] nums, int s) {
        if(nums == null || nums.length == 0) return -1;
        res = 0;
        dfs(nums, 0, s, 0);
        return res;
    }

    void dfs(int[] nums, int index, int s, int sum){
        if(index == nums.length){
           if(sum == s){
               res++;
           }
           return;
        }
        //sum += nums[index];
        dfs(nums, index + 1, s, sum - nums[index]);
        //sum -= 2*nums[index];//临时还原一下状态
        dfs(nums, index + 1, s, sum + nums[index]);
    }
}

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

class Solution {
    public int findTargetSumWays(int[] nums, int s) {
        //仍然采用动态规划方法
        int sum = 0;
        for(int num :nums){
            sum += num;
        }
        if(Math.abs(s) > sum) return 0;//因为元素都大于0，不加绝对值也是可以的
        //同时要注意这里必须得判断，后面的主程序无法识别这个，因为会数组越界

        int len = nums.length;
        int t = 2*sum + 1;
        int[][] dp = new int[len][t];
        //由于dp表格可能出现负值，整体移动
        //对于第一个应当特殊处理
        if(nums[0] == 0){//初始化第一行
            //dp[0][0] = 2;//加0减0都是成立的
            dp[0][sum] = 2;
        }else{
            dp[0][-nums[0] + sum] = 1;
            dp[0][nums[0] + sum] = 1;//整体移动sum,不然会出错
        }

        for(int i = 1; i < len; i++){
            for(int j = 0; j < t; j++){//j取值范围0-t
                //这里可以直接操作，因为都是转化过的
                //dp[i][j]原始为0
                if(j >= nums[i]) dp[i][j] += dp[i - 1][j - nums[i]];
                if(j + nums[i] < t) dp[i][j] += dp[i - 1][j + nums[i]];
            }
        }

        return dp[len - 1][s + sum];
    }
}

3.转化为背包问题
01背包其实不是这种解法的重点，重点是怎么把题目转化成求解01背包的形式。

如果只是单纯的求解和为某个S的组合个数，那就是01背包。。。

但是这题目中不仅有加，还有减，就得进行一个转化了。

思路就是把整个集合看成两个子集，Q表示整个集合，P表示正数子集，N表示负数子集， T表示目标和，用S(X)S(X)表示集合的求和函数，集合中均为非负数，N集合是指选中这部分元素作为负数子集。

S(P) - S(N) = T
S(P)−S(N)=T

S(P) + S(N) + S(P) - S(N) = T + S(P) + S(N)
S(P)+S(N)+S(P)−S(N)=T+S(P)+S(N)

2S(P) = S(Q) + T
2S(P)=S(Q)+T

也就是：正数集的和的两倍 == 等于目标和 + 序列总和

所以问题就转换成了，找到一个正数集P，其和的两倍等于目标和+序列总和。

class Solution {
    public int findTargetSumWays(int[] nums, int s) {
        //仍然采用动态规划方法
        int sum = 0;
        for(int num :nums){
            sum += num;
        }
        if(Math.abs(s) > sum) return 0;
        
        int len = nums.length;
        s = s + sum;//别忘了除2
        if(s % 2 == 1) return 0;//这种情况也会是不存在
        s /= 2;
        
        int dp[] = new int[s + 1];
        dp[0] = 1;
        for(int i = 0; i < len; i++){//注意这里要从0开始，不是从1
            for(int j = s; j >= nums[i]; j--){//因为呀要参考上一行的，所以要倒着来
                dp[j] += dp[j - nums[i]];
            }
        }
        
        return dp[s];
    }
}

0-1背包问题转为二维问题全纪录

class Solution {
    public static void main(String[] args) {
        int[] arr = {0,0,0,0,0,0,0,0,1};
        new Solution().findTargetSumWays(arr, 1);
    }
    public int findTargetSumWays(int[] nums, int s) {
        //仍然采用动态规划方法
        int sum = 0;
        for(int num :nums){
            sum += num;
        }
        if(Math.abs(s) > sum) return 0;

        int len = nums.length;
        s = s + sum;//别忘了除2
        if(s % 2 == 1) return 0;//这种情况也会是不存在
        s /= 2;


        /*int dp[][] = new int[len][s + 1];
        dp[0][0] = 1;
        if(s >= nums[0]) dp[0][nums[0]] = 1;

        for(int i = 1; i < len; i++){
            for(int j = 0; j <= s; j++){
                dp[i][j] = dp[i - 1][j];
                if(j >= nums[i]){
                    dp[i][j] += dp[i - 1][j - nums[i]];
                }

            }
        }
        for(int i = 0; i< len; i++){
            for(int j = 0; j <= s; j++){
                System.out.print(dp[i][j] + " ");
            }
            System.out.println();
        }
        return dp[len -1][s];
*/

        int dp[] = new int[s + 1];
        dp[0] = 1;
        for(int i = 0; i < len; i++){
            for(int j = s; j >= nums[i]; j--){//因为呀要参考上一行的，所以要倒着来
                dp[j] += dp[j - nums[i]];
            }
            for(int j = 0; j <=s; j++){
                System.out.print(dp[j] + " ");
            }
            System.out.println();
        }
        return dp[s];
    }
}

被注释的即为二维的做法，但是最终通过率是130/138,关键就在于dp[0][0]=1，这个出了问题，对于dp[len-1][s + 1]其真的有可能出现数组元素值为0 的情况：


二者dp[0][0]就不相同，这就是分歧所在；
所以dp数组应为dp[len + 1][s + 1]应对某一元素为0 的状态，这里与474题相似，同设置了dp[len + 1]选项，所以在dp[0][x]的初始化，会有很多没考虑到的情况

2.dp[0][0]=1还是0，其实不用太紧张，他只会影响到第一行dp表的取值（对于二维dp而言,一维影响还是很广的）
上述代码只需要修改一下一处即可
if(s >= nums[0]) dp[0][nums[0]] = 1; ===>>> if(s >= nums[0]) dp[0][nums[0]] += 1;
代码如下：

class Solution {
   
    public int findTargetSumWays(int[] nums, int s) {
        //仍然采用动态规划方法
        int sum = 0;
        for(int num :nums){
            sum += num;
        }
        if(Math.abs(s) > sum) return 0;

        int len = nums.length;
        s = s + sum;//别忘了除2
        if(s % 2 == 1) return 0;//这种情况也会是不存在
        s /= 2;

        int dp[][] = new int[len][s + 1];
        dp[0][0] = 1;
        if(s >= nums[0]) dp[0][nums[0]] += 1;

        for(int i = 1; i < len; i++){
            for(int j = 0; j <= s; j++){
                dp[i][j] = dp[i - 1][j];
                if(j >= nums[i]){
                    dp[i][j] += dp[i - 1][j - nums[i]];
                }

            }
        }
        return dp[len -1][s];
    }
}

== 总结一下，需要注意的点：==
1.直接抄下来，dp[i][j] = dp[i - 1][j],先继承前面的结果，也就是数组元素不一定全部使用
2.累加：dp[i][j] += dp[i - 1][j - nums[i]];这里也加上了1的结果，也就是去除一种nums[i]都对应一种组合情况，叠加即可
3.dp[len][s + 1]要注意dp[0][x]的初始化，注意是否存在等于0 的情况，因此可以考虑设置为dp[len + 1][s + 1]
对应代码如下：

class Solution {
    public static void main(String[] args) {
        int[] arr = {0,0,0,0,0,0,0,0,1};
        new Solution().findTargetSumWays(arr, 1);
    }
    public int findTargetSumWays(int[] nums, int s) {
        //仍然采用动态规划方法
        int sum = 0;
        for(int num :nums){
            sum += num;
        }
        if(Math.abs(s) > sum) return 0;

        int len = nums.length;
        s = s + sum;//别忘了除2
        if(s % 2 == 1) return 0;//这种情况也会是不存在
        s /= 2;


        int dp[][] = new int[len + 1][s + 1];

        dp[0][0] = 1;//只需要把参照设为1即可，与L474对比，那个为0，但是循环中每次都会+1
        for(int i = 1; i <= len; i++){
            for(int j = 0; j <= s; j++){
                dp[i][j] = dp[i - 1][j];
                if(j >= nums[i - 1]){//注意是i- 1
                    dp[i][j] += dp[i - 1][j - nums[i - 1]];
                }

            }
        }
        //方便随时打印查看
        for(int i = 0; i<= len; i++){
            for(int j = 0; j <= s; j++){
                System.out.print(dp[i][j] + " ");
            }
            System.out.println();
        }
        return dp[len][s];

    }
}