【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?

思路

开始想用搜索，搜索当前target的组成方案数。超时。
看了花花酱的视频，记忆化搜索，dp[num] += dp[num-nums[j]]，遍历时只会遍历数组中的数字。
尝试改成dp，这样遍历范围是1~target，最后无解的数据 中间过程的答案溢出了。
…记忆化搜索和动态规划，各有千秋。如果我超时的时候，换一个思路，我想求的是到当前target的方案数，如果能把它记录下来，当前target和数组中的数字能组成的新的target方案数就得到了。
关于顺序，一开始想着，这种 1 1 2 的解会搜出两个来，实际上因为数组中没有重复的数字，每个位置安排一个数字，得到的解已经不会是重复的了。

代码

记忆化搜索

class Solution {
public:
    int combinationSum4(vector<int>& nums, int target) {
        vector<int> mp(target+1, -1);
        return dfs(nums, target, mp);
    }
    
    int dfs(vector<int>& nums, int target, vector<int>& mp) {
        if (target < 0) return 0;
        if (target == 0) return 1;
        
        if (mp[target] != -1) return mp[target];
        
        int ans = 0;
        
        for (int i=0; i<nums.size(); ++i) {
            ans += dfs(nums, target-nums[i], mp);
        }
        return mp[target] = ans;
    }
};

动态规划

class Solution {
public:
    int combinationSum4(vector<int>& nums, int target) {
        vector<int> dp(target + 1, 0); // dp[i] # of combinations sum up to i
        dp[0] = 1;
        for (int i = 1; i <= target; ++i)
            for (const int num : nums)
                if (i - num >= 0)
                    dp[i] += dp[i - num];           
        return dp[target];
    }
};