lc 第四九四题 findTargetSumWays 目标和

回溯法

回溯思路

任何算法的核心都是穷举，回溯算法就是一个暴力穷举算法

def backtrack(路径, 选择列表):
    if 满足结束条件:
        result.add(路径)
        return

    for 选择 in 选择列表:
        做选择
        backtrack(路径, 选择列表)
        撤销选择

对于每个数字 nums[i]，我们可以选择给一个正号 + 或者一个负号 -然后利用回溯模板穷举出来所有可能的结果，数一数到底有几种组合能够凑出 target 不就行了嘛？

class Solution {
    static int result;
    public int findTargetSumWays(int[] nums, int target) {
        result=0;
        if(nums.length==0)  return 0;
        backtrack(nums,0,target);
        return result;
    }

    public static void backtrack(int[] nums, int i, int rest) {
        if(i==nums.length){
            if(rest==0){
                result++;
            }
            return;
        }
        rest+=nums[i];
        backtrack(nums,i+1,rest);
        rest-=nums[i];

        rest-=nums[i];
        backtrack(nums,i+1,rest);
        rest+=nums[i];
    }

}

直接回溯 没有剪枝 时间太久

 回溯优化

抽象出来两种递归：

        backtrack(i + 1, rest - nums[i]);

        backtrack(i + 1, rest + nums[i]);

如果nums[i]=0，呢莫你就会发现

        backtrack(i + 1, rest);

        backtrack(i + 1, rest);

出现了两个状态相同的递归方程，即有了重叠子问题。

这就是重叠子问题，而且只要我们能够找到一个重叠子问题，那一定还存在很多的重叠子问题。

考虑到重叠子问题，使用备忘录来改善也就是剪枝。

备忘录一般通过HashMap来实现

class Solution {
    static int result;
    static HashMap<String, Integer> memo;
    public int findTargetSumWays(int[] nums, int target) {
        memo= new HashMap<>();
        result=0;
        if(nums.length==0)  return 0;
        return backTrackMemo(nums,0,target);
    }

    
    public static int backTrackMemo(int[] nums, int i, int rest) {
        if(i==nums.length){
            if(rest==0){
                return 1;
            }
            return 0;
        }
        String key = i + "," + rest;
        if(memo.containsKey(key)){
            return memo.get(key);
        }
        result=backTrackMemo(nums,i+1,rest-nums[i])+backTrackMemo(nums,i+1,rest+nums[i]);
        memo.put(key,result);
        return result;
    }

}

特别注意 lc测用例的时候是只调用呢个解决类 而如果要用到全局变量 会在两个用例一起测试时出现问题，所以需要先定义全局变量，然后在解决类中赋值为0或者null.

在优化回溯法的时候，其实已经找出了状态转移方称，即可以转动态规划来解决这个问题。

sum(A) - sum(B) = target
sum(A) = target + sum(B)
sum(A) + sum(A) = target + sum(B) + sum(A)
2 * sum(A) = target + sum(nums)

问题转化成sum中存在有几种元素子集和使得sum(A)=[target+sum(nums)]/2

首先想到的时二维dp数组

在考虑问题本质方面 数的加减一定是在整个数组和sum一定在-sum~+sum之间 所以sum +target的和一定是个正数

整个二维dp数组如果最后一位是0,则不会算到这个0加减的两次。所以需要加while循环来调整最后一位使它不为0

class Solution {
    static int result;
    
    public int findTargetSumWays(int[] nums, int target) {
        result=0;
        if(nums.length==0)  return 0;
        return backTrackDP(nums,target);
    }
     public static int backTrackDP(int[] nums, int target){
        //定义DP二维数组dp[i][j]:表示总和为j，从i到n个数中选择，则最多有n种方法装满背包。
        //dp[0][……]=0  dp[……][0]=1
        //状态转方程 dp[i][j]=dp[i+1][j]+dp[i+1][j-nums[i]]
        //最后一位不能为0 要不然考虑不了最后一位0的加或者不加
        int n=nums.length;
        int sum=0;
        for(int i=0;i<n;i++) {
            sum += nums[i];
        }
        if (sum + target < 0 || (sum + target) % 2 == 1) {
            return 0;
        }
        sum=(sum+target)/2;
        int[][] dp=new int[n][sum+1];
        for(int i=0;i<n;i++) dp[i][0]=1;
        int index=n-1;
        while(nums[n-1]==0){
            index--;
            if(index<0){
                return (int)Math.pow(2,n);
            };
            int temp=nums[index];
            nums[index]=nums[n-1];
            nums[n-1]=temp;
            
        }
        for(int i=n-1;i>=0;i--){
            for(int j=0;j<sum+1;j++){
                if(i==n-1){
                    if(j==nums[i]){
                        dp[i][j]=1;
                    }
                }else{
                    if(j>=nums[i]){
                        dp[i][j]=dp[i+1][j]+dp[i+1][j-nums[i]];
                    }else{
                        dp[i][j]=dp[i+1][j];
                    }
                }
            }
        }
    return dp[0][sum];
    }
}