leetcode 377. Combination Sum IV 换钱问题

最新推荐文章于 2021-09-10 11:45:24 发布

原创最新推荐文章于 2021-09-10 11:45:24 发布 · 755 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode

leetcode 专栏收录该内容

57 篇文章

订阅专栏

本文探讨了一组正整数中所有可能的组合方式，这些组合的总和等于一个正整数目标值。提供了两种解决方案：一种是使用动态规划，另一种是采用递归方式并缓存中间结果以减少重复计算。

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];