目标和

494. 目标和
在这里插入图片描述
未使用到记忆化数组

class Solution {
public:
    int ans;

    void dfs(int index,int count,vector<int>& nums,int target){
        if(index==nums.size() && count==target){
            ans++;
            return;
        }
        if(index<0 ||index>=nums.size()){
            return;
        }
        //对于每个index位置的数 都必须有两种选择 
        //+ 或者 -
        count+=nums[index];//选择+
        dfs(index+1,count,nums,target);
        count-=nums[index];//恢复

        count-=nums[index];//选择-
        dfs(index+1,count,nums,target);
        count+=nums[index];//恢复

    }
    int findTargetSumWays(vector<int>& nums, int target) {
        dfs(0,0,nums,target);
        return ans;
    }
};

dfs简洁写法

 void dfs(int index,int count,vector<int>& nums,int target){
        if(index==nums.size() && count==target){
            ans++;
            return;
        }
        if(index<0 ||index>=nums.size()){
            return;
        }
        //对于每个index位置的数 都必须有两种选择 
        //+ 或者 -
        dfs(index+1,count+nums[index],nums,target);
        dfs(index+1,count-nums[index],nums,target);
    }

使用记忆化数组
思路：
在回溯法基础上，为了避免每一次都需要重复走以及计算过的解
加入memo数组储存 前index个位置，目标值为count 的值

回溯时，某些值不用计算
因此，回溯的返回值应该为int 并将此值保存到 memo[index] [count]

class Solution {
public:
    vector<unordered_map<int, int>> memo;
    
     int dfs(int index,int count,vector<int>& nums,int target) {
        if(index == nums.size() && count==target){
                return 1;
        }
        if(index<0 ||index>=nums.size()){
            return 0;
        }
        //memo[index][target-count]存在
        if (memo[index].count(target-count)){
            return memo[index][target-count];
        }
        int res = 0;
        res=    dfs(index+1,count+nums[index],nums,target)+
                dfs(index+1,count-nums[index],nums,target);
        memo[index][target-count] = res;
        return res;
    }
    int findTargetSumWays(vector<int>& nums, int target) {
        //需要保存的为index和count =>memo
        memo.resize(nums.size());
        return dfs(0,0,nums,target);
    }
};

一般记忆化搜索能做的题目，都可以用dp做
思路：
热评
在这里插入图片描述
求 sum( P ) 转化为01背包问题
用价值和重量都为nums数组的物品，较好凑满x=(target + sum)/2的背包方案数

dp[index][count]为前index位置（包括index）能凑满值为count的方案数

dp版本：

class Solution {
public:
    //dp
    int findTargetSumWays(vector<int>& nums, int target) {
        int sum = 0;
        int n=nums.size();
        for(int num : nums){
            sum+=num;
        }
        if(sum<target || (sum+target)%2==1){
            return 0;
        }
        int x=(target + sum)/2;
        if(x<0)
            return 0;
        vector<vector<int>> dp(n+1,vector<int>(x+1,0));
        //边界
        for(int i=0;i<=n;i++)
            dp[i][0] = 0;
        for(int j=1;j<=x;j++)
            dp[0][j] = 0;
        dp[0][0]=1;
        for(int index=1;index<=n;index++){
            int num=nums[index-1];//索引为i（从1开始）
            for(int count=0;count<=x;count++){
                if(count<num)
                    dp[index][count]=dp[index-1][count];
                else{
                    dp[index][count]=dp[index-1][count]+dp[index-1][count-num];
                }
            }
        }
        return dp[n][x];
    }


};