LeetCode 39. Combination Sum && 40. Combination Sum II && 216. Combination Sum III

9 篇文章 0 订阅
1 篇文章 0 订阅

39. Combination Sum

Given a set of candidate numbers (C) (without duplicates) and a target number (T), find all unique combinations in C where the candidate numbers sums to T.

The same repeated number may be chosen from C unlimited number of times.

Note:
All numbers (including target) will be positive integers.
The solution set must not contain duplicate combinations.
For example, given candidate set [2, 3, 6, 7] and target 7,
A solution set is:

[
  [7],
  [2, 2, 3]
]

在所给的正数数组(不含重复元素)中,找出所有的元素组合使得它们的和等于目标值。这些找到的元素组合要以非递减顺序排列,这些组合不能够是重复的,但数组中元素可以重复使用。
看一下题目给出的例子:看看例子:[2,3,6,7], 7
搜索过程:

2开始进行搜索,由于允许重复:
2,2,2
接续重复2,和为8,大于7,所以退一步再从下一个数开始搜:
22
223
此时和=7,符合要求。后续的搜索:
226 不符
227 不符
233 不符
236 不符
237 不符
333 不符
336 不符
337 不符
......
67 不符
7 符合

通过这样的搜索过程就得到了需要的元素组合。思路是非常朴素的穷举,一个个尝试,试错了就退回——所以这里我们使用回溯法。

另写一个递归函数,加入三个变量,res保存所有已经得到的解,resItem是其中一个目标值组合解,index是当前搜索范围的起点。每次调用新的递归函数时,target减去当前数组元素:

vector<vector<int> > combinationSum(vector<int> &candidates, int target){
        vector<vector<int>> rs;
        if (candidates.size() == 0) return rs;

        sort(candidates.begin(),candidates.end());
        vector<int> resItem;
        dfs(candidates,rs,resItem,0,target);
        return rs;
    }

    //cdd是原数组,res是目标值组合集合,resItem是其中一个目标值组合解,index是当前搜索范围的起点,target是目标值
    void dfs(vector<int> &cdd ,vector<vector<int>> &res ,vector<int> &resItem ,int index ,int target){
        if (target == 0) {//表明已经找到所求组合
            res.push_back(resItem);
            return;
        }
        if (target < cdd[index]) return;//此时sum必定大于target
        for (int i = index ; i < cdd.size(); ++i){
            resItem.push_back(cdd[i]);
            dfs(cdd,res,resItem,i,target-cdd[i]);
            resItem.pop_back();//回溯
        }
    }

9ms通过。

第一版代码,没有用递归,15ms。

 vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        int cur = candidates.size() - 1;
        vector<vector<int>> rs;
        while (cur >= 0)
        {
            int remain = target - candidates[cur];
            if (remain == 0)
            {
                rs.push_back({ candidates[cur] });
            }
            else if (remain > 0)
            {
                auto beg = candidates.begin();
                vector<int> subCandidates = vector<int>(beg, beg + cur + 1);
                vector<vector<int>> temp = combinationSum(subCandidates, remain);
                if (temp.size() != 0) {
                    for (auto &item : temp) {
                        item.push_back(candidates[cur]);
                        rs.push_back(item);
                    }
                }
            }
            --cur;
        }
        return rs;
    }

40. Combination Sum II

Given a collection of candidate numbers (C) and a target number (T), find all unique combinations in C where the candidate numbers sums to T.

Each number in C may only be used once in the combination.

Note:
All numbers (including target) will be positive integers.
The solution set must not contain duplicate combinations.
For example, given candidate set [10, 1, 2, 7, 6, 1, 5] and target 8,
A solution set is:

[
  [1, 7],
  [1, 2, 5],
  [2, 6],
  [1, 1, 6]
]

本质没有区别,只是之前那道题给定数组中的数字可以重复使用,而这道题不能,而且这道题给定数组中可能有重复数字。所以改动的地方有两处:1.递归调用里的index传参要改为i+1;2.在递归的for循环里跳过数组中重复项。

vector<vector<int> > combinationSum2(vector<int> &candidates, int target){
        vector<vector<int>> rs;
        if (target <= 0 || candidates.size() == 0) return rs;//因为数组元素都是正数,所以目标值=0时必定找不到

        sort(candidates.begin(),candidates.end());
        vector<int> resItem;
        dfs(candidates,rs,resItem,0,target);
        return rs;
    }

    //cdd是原数组,res是目标值组合集合,resItem是其中一个目标值组合,index是当前搜索范围的起点,target是目标值
    void dfs(vector<int> &cdd ,vector<vector<int>> &res ,vector<int> &resItem ,int index ,int target){
        if (target == 0) {//表明已经找到所求组合
            res.push_back(resItem);
            return;
        }
        if (target < cdd[index]) return;//此时sum必定大于target
        for (int i = index ; i < cdd.size(); ++i){
            if (i > index && cdd[i] == cdd[i-1]) continue;
            resItem.push_back(cdd[i]);
            dfs(cdd,res,resItem,i+1,target-cdd[i]);
            resItem.pop_back();//回溯
        }
    }

第一版代码:

vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end());
        vector<vector<int>> rs;
        test(candidates, target, rs);
        return rs;
    }

    void test(vector<int>& candidates, int target, vector<vector<int>>&rs) {
        int cur = candidates.size() - 1;
        while (cur >= 0)
        {
            int remain = target - candidates[cur];
            if (remain == 0)
            {
                rs.push_back({ candidates[cur] });
            }
            else if (remain > 0)
            {
                auto beg = candidates.begin();
                vector<int> subCandidates = vector<int>(beg, beg + cur);
                vector<vector<int>> temp;
                test(subCandidates, remain, temp);
                if (temp.size() != 0) {


                    for (auto &item : temp){
                        item.push_back(candidates[cur]);
                        rs.push_back(item);
                    }
                }
            }
            while (cur > 0 && candidates[cur] == candidates[cur - 1])
            {
                --cur;
            }
            --cur;
        }
    }

216. Combination Sum III

Find all possible combinations of k numbers that add up to a number n, given that only numbers from 1 to 9 can be used and each combination should be a unique set of numbers.

Example 1:

Input: k = 3, n = 7

Output: [[1,2,4]]

Example 2:

Input: k = 3, n = 9

Output:
[[1,2,6], [1,3,5], [2,3,4]]

这道题跟之前两道有点不太一样。从1~9这九个数字中挑选k个不重复的数,使得它们的和等于n。但本质上还是差不多的。

vector<vector<int>> combinationSum3(int k, int n) {
        if (k > 9 || n < k*(k+1)/2 || n > (9-k + 1 + 9)*k/2) return{}; //(首项+末项)*项数/2
        vector<vector<int>> rs;
        vector<int> resItem;
        cs3dfs(rs,resItem,1,k,n);
        return rs;
    }
    void cs3dfs(vector<vector<int>> &res ,vector<int> &resItem ,int index , int k ,int n){
        if (n == 0 && resItem.size() == k) {res.push_back(resItem); return;}
        if (n < index) return;
        if (resItem.size() < k){
            for (int i = index ;i <= 9 ; ++i){
                resItem.push_back(i);
                cs3dfs(res,resItem,i+1,k,n-i);
                resItem.pop_back();
            }
        }
    }
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值