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?
tags: dp
1)刚开始肯定想到回溯方法,但是写出来超时了,代码如下:
class Solution {
public: //backtracking 超时?
int combinationSum4(vector<int>& nums, int target) {
int res = 0;
sort(nums.begin(), nums.end());
backtracking(nums, target, 0, res);
return res;
}
void backtracking(vector<int>& nums, int target, int prevSum, int& res){
int temp, i, size = nums.size();
for(i = 0; i < size; ++i){
temp = prevSum+nums[i];
if(temp<target) backtracking(nums, target, temp, res);
else if(temp==target){
res++;
break;
}
else break;
}
}
};
2)后来看tags是动态规划,想了很久没想出来,网上看了下,明白了。动态规划状态方程:
dp[target]=sum(dp[target-nums[i]]) (for i=0..num.size()-1)
dp[target] 代表一共有多少种可能。
那么从target-nums[i] 变为 target,只有一种途径,也就是加上nums[i];那么这种途径带来的次数是dp[target-nums[i]];
我们遍历所有的nums[i],然后求和即可以得到dp[target]的结果。
代码如下:
class Solution{
public:
int combinationSum4(vector<int>& nums, int target){
if(nums.size()==0) return 0;
vector<int> dp(target+1, 0);
dp[0] = 1;
for(int i =1; i <= target; i++)
{
for(auto val: nums)
if(val <= i) dp[i] += dp[i-val];
}
return dp[target];
}
};