leetcode 377. 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?

注意这里返回的数目，并不是组合数目，结果中排列不同也算不同的结果。
先给出两种方法解决这个允许重复的情况

public int combinationSum4(int[] nums, int target) {
        if(nums==null ||nums.length==0|| target<0) return 0; 
        Arrays.sort(nums);
        int[] dp = new int[target+1];
        for(int i=1; i<target+1; i++){
            for(int num:nums){
                if(num > i){
                    break;
                }else if(num==i){
                    dp[i]++;
                }else{
                    dp[i] += dp[i-num];
                }
            }
        }
        return dp[target];
    }

这种解法的思路是先对元素数组进行排序，然后分析，用该数组等到0-target的组合数。排序的目的是，当数组中的元素大于组合数，即可break掉。

另一种解法是递归的方式，但是保存历史结果，减少递归调用次数

    public int combinationSum4(int[] nums, int target) {
        if(nums==null ||nums.length==0|| target<0) return 0; 
        int[] res = new int[target+1];
        Arrays.fill(res, -1);
        res[0] = 1;
        return helper(nums, target, res);
    }

    public int helper(int[] nums, int target, int[] res){
        if(res[target]!=-1){
            return res[target];
        }
        int t = 0;
        for(int i=0; i< nums.length; i++){
            if(target >= nums[i]){
                t += helper(nums, target - nums[i], res);
            }
        }
        res[target] = t;
        return res[target];

    }

这个思路跟前面其实是一样的，代码比较清楚了。

如果不允许重复结果出现，即1,1,2等同于结果1,2,1。
那么动态规划设计的思路应该是，dp[i][j]表示用前i个数组个得到j的方法数

        if(nums==null ||nums.length==0|| target<0) return 0; 

        int[][] dp = new int[nums.length][target+1];
        for(int i=0; i< nums.length; i++){
            dp[i][0]=1;
        }
        for(int j=1; nums[0]*j < target+1;j++){
            dp[0][nums[0]*j] = 1;
        }

        for(int i=1; i<nums.length; i++){
            for(int j=1; j < target+1; j++){
                dp[i][j] = dp[i-1][j];
                dp[i][j] += j-nums[i] >= 0?dp[i][j-nums[i]]:0;
            }
        }
        return dp[nums.length-1][target];