leetcode 377 Combination Sum IV 动态规划

377. Combination Sum IV

 

Question Editorial Solution

  My Submissions

• Total Accepted: 3456
• Total Submissions: 8922
• Difficulty: Medium

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?

Credits:
Special thanks to @pbrother for adding this problem and creating all test cases.

/**
 *这个方法每次重复计算已经算过的内容，会超时 
 * 

public class Solution {
    public int combinationSum4(int[] nums, int target) {
        //Arrays.sort(nums);
        int len=nums.length;
        //int flag = Arrays.BinarySearch(nums,target);
        int flag=-1;
        int ret=0;
        if(len==1&&nums[0]!=target)return 0;
        if(len==1&&nums[0]==target)return 1;
        for(int i=0;i<len;i++){
            if(nums[i]==target){
                flag=i;
                break;
            }
        }
        if(flag>0){
            ret=1+combinationSum4(nums,target-nums[flag]);
        }
        if(flag<0){
            int i;
            for(i=len-1;i>=0;i--){
                if(nums[i]<target){
                    break;
                }
            }
            int[] temp=new int[i+1];
            for(int j=0;j<i;j++)temp[j]=nums[j];
            ret=combinationSum4(nums,target-nums[i])+combinationSum4(temp,target);
            
        }
        return ret;
    }
}

 */

/**
 *这个方法每次计算记录下已经算过的内容，不用重复，更简单
 * 这个是参考的。。。
 * 
 */
 public class Solution {
    public int combinationSum4(int[] nums, int target) {
        if(nums == null || nums.length == 0 || target < 0) {
		return 0;
	    }
    	Arrays.sort(nums); //Not required, but can help in exit out of loop early.
	    int[] combinations = new int[target + 1];
	    combinations[0] = 1;
	    int length = nums.length; // so that length is not calculated every time.
	    for (int i = 1; i <= target; i++) {
		    for (int j = 0; j < length; j++) {
			    if(i - nums[j] < 0) {
			    	break;
		    	}
			    if( i == nums[j]) {
			    	combinations[i] += 1;
			    }
			    else if (i - nums[j] >= 0) {
			    	combinations[i] += combinations[i - nums[j]];
		    	}
	    	}
    	}
	    return combinations[target];
    }
 }