377. Combination Sum IV-动态规划

最新推荐文章于 2024-07-03 18:00:24 发布

i-Blue

最新推荐文章于 2024-07-03 18:00:24 发布

阅读量1.3k

点赞数 1

CC 4.0 BY-SA版权

分类专栏： LeetCode 动态规划 backTracking 文章标签： leetcode DP

本文链接：https://blog.youkuaiyun.com/u011567017/article/details/52626439

LeetCode 同时被 3 个专栏收录

45 篇文章

订阅专栏

动态规划

15 篇文章

订阅专栏

backTracking

3 篇文章

订阅专栏

本文探讨了组合总和IV问题，即给定一个不含重复正整数的数组，求所有可能组合的数量以达到特定目标值。通过对比回溯法与动态规划方法，详细解析了动态规划解决方案的设计思路及实现过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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