Combination Sum IV

Given an integer array with all positive numbers and no duplicates, find the number of possible combinations that add up to a positive integer target.

Example:

nums = [1, 2, 3]
target = 4

The possible combination ways are:
(1, 1, 1, 1)
(1, 1, 2)
(1, 2, 1)
(1, 3)
(2, 1, 1)
(2, 2)
(3, 1)

Note that different sequences are counted as different combinations.

Therefore the output is 7.

Follow up:
What if negative numbers are allowed in the given array?
How does it change the problem?
What limitation we need to add to the question to allow negative numbers?

思路1：典型的backtracking，但是会time out，也就是说会有更好的解法，网上一搜，果然有，就是dp。

class Solution {
    public int combinationSum4(int[] nums, int target) {
        if(nums == null || nums.length == 0) return 0;
        int[] res = {0};
        combinationSum4Helper(nums, target, 0, res);
        return res[0];
    }
    
    public void combinationSum4Helper(int[] nums, int target, int curSum, int[] res) {
        if(curSum > target){
            return;
        } else if( curSum == target){
            res[0]++;
            return;
        } else {
            for(int i=0; i<nums.length; i++){
                // choose;
                curSum += nums[i];
                
                // explore;
                combinationSum4Helper(nums, target, curSum, res);
                
                // unchoose;
                curSum -= nums[i];
            }
        }
    }
}

思路2：dp[i] 表示的物理意义就是sum大小为i的时候，总共能表示的种类个数，那么这题就跟coin change的题目一模一样了。dp[i] += dp[i-nums[i]];

我们需要一个一维数组dp，其中dp[i]表示目标数为i的解的个数，然后我们从1遍历到target，对于每一个数i，遍历nums数组，如果i>=x, dp[i] += dp[i - x]。这个也很好理解，比如说对于[1,2,3] 4，这个例子，当我们在计算dp[3]的时候，3可以拆分为1+x，而x即为dp[2]，3也可以拆分为2+x，此时x为dp[1]，3同样可以拆为3+x，此时x为dp[0]，我们把所有的情况加起来就是组成3的所有情况了

class Solution {
    public int combinationSum4(int[] nums, int target) {
        int[] dp = new int[target + 1];
        for(int num: nums) {
            if(num <= target) {
                dp[num] = 1;
            }
        }
        // dp[i] += dp[i - num];
        for(int i = 0; i <= target; i++) {
            for(int num: nums) {
                if(i - num >= 0) {
                    dp[i] += dp[i - num];
                }
            }
        }
        return dp[target];
    }
}