组合总和4

问题描述

给你一个由 不同 整数组成的数组 nums ，和一个目标整数 target 。请你从 nums 中找出并返回总和为 target 的
元素组合的个数。

题目数据保证答案符合 32 位整数范围。

1 <= nums.length <= 200
1 <= nums[i] <= 1000
nums 中的所有元素 互不相同
1 <= target <= 1000

这道题其实思想不难，回溯的写法一下子就写出来了。但是很不幸，记忆化搜索的方法提交他都没过

//普通递归
class Solution {
    private int res = 0;

    private void dfs(int[] nums, int target) {
        if(target <= 0) {
            if(target == 0) res++;
            return;
        }

        for(int i = 0; i < nums.length; i++) {
            dfs(nums, target-nums[i]);
        }
    }
    public int combinationSum4(int[] nums, int target) {
        dfs(nums, target);
        return res;
    }
}

//记忆化搜素
class Solution {
    private int dfs(int[] dp, int[] nums, int target) {
        if(target == 0) {
            return 1;
        }

        if(dp[target] != 0) return dp[target];
        for(int i = 0; i < nums.length; i++) {
            if(target-nums[i] >= 0) dp[target] += dfs(dp, nums, target-nums[i]);
        }
        return dp[target];
    }
    public int combinationSum4(int[] nums, int target) {
        int[] dp = new int[target+1];
        return dfs(dp, nums, target);
    }
}

总结来说呢，还是对这道题具体的实现流程不了解导致没写出来动态规划的方法，看了下题解：

茅塞顿开

一句话说明白就是：dp[target] = （dp[target-num[i]]之和），其中i>=0,target-num[i]>=0。
知道了这个，一下子就写出来了。我们令dp[0] = 1，递推得到每个结果即可

class Solution {
    public int combinationSum4(int[] nums, int target) {
        int[] dp = new int[target+1];
        dp[0] = 1;
        for(int i = 1; i <= target; i++) {
            for(int j = 0; j < nums.length; j++) {
                if(nums[j] <= i) dp[i] += dp[i-nums[j]];
            }
        }
        return dp[target];
    }
}

结果: