39组合总和 40组合总和II 216组合总和III

题目

给定一个无重复元素的正整数数组 candidates 和一个正整数 target ，找出 candidates 中所有可以使数字和为目标数 target 的唯一组合。

candidates 中的数字可以无限制重复被选取。如果至少一个所选数字数量不同，则两种组合是唯一的。

对于给定的输入，保证和为 target 的唯一组合数少于 150 个。

示例 1：

输入: candidates = [2,3,6,7], target = 7
输出: [[7],[2,2,3]]
示例 2：

输入: candidates = [2,3,5], target = 8
输出: [[2,2,2,2],[2,3,3],[3,5]]
示例 3：

输入: candidates = [2], target = 1
输出: []
示例 4：

输入: candidates = [1], target = 1
输出: [[1]]
示例 5：

输入: candidates = [1], target = 2
输出: [[1,1]]

class Solution {
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        vector<vector<int>> result;//存储结果
        vector<int> path;//存储当前路径
        sort(candidates.begin(), candidates.end());//排序，方便剪枝
        dfs(candidates, result, path, target, 0);
        return result;
    }
private:
	//start表示此次搜索开始的下标
    void dfs(vector<int>& candidates, vector<vector<int>>& result, vector<int>& path, int target, int start){
        if(target==0){//递归边界，找到了一种情况
            result.push_back(path);
            return;
        }
        //寻找该位置可能的每一种数字
        for(int i=start; i<candidates.size(); ++i){
        	//if(i > begin && candidates[i] == candidates[i-1]) continue
        	//添加这一行即可解决组合总和II，完成去重
            if(target<candidates[i]) return;//剪枝
            path.push_back(candidates[i]);
            dfs(candidates, result, path, target-candidates[i],i);//由于数字可重复，只修改target的值
            path.pop_back();
        }
    }
};

• 思路
  • 先思考函数参数是什么
    • 存储最终结果的result数组，存储当前结果的path数组，存储可选数字的数组candidate，存储目标的target，存储开始下标的start
  • 对candidate排序，方便剪枝
  • 如果target为0，表示找到了一种情况，将它加入到result中，直接返回
  • for循环确定当前层的每一种可能，从start开始，到可选数组的最后一个数都有可能
    • 如果当前下标对应的数字已经大于target，后续的数字就更加不可能，此时直接返回
    • 否则，将当前下标的数字加入到path数组中，递归搜索下一层，由于数字可重复，此时传入参数只有target发生变化
    • 递归结束后恢复现场

组合总和II

给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用一次。

注意：解集不能包含重复的组合。

示例 1:

输入: candidates = [10,1,2,7,6,1,5], target = 8,
输出:
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]
示例 2:

输入: candidates = [2,5,2,1,2], target = 5,
输出:
[
[1,2,2],
[5]
]

class Solution {
public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        vector<vector<int>> result;
        vector<int> path;
        sort(candidates.begin(), candidates.end());
        dfs(candidates, result, path, target, 0);
        return result;
    }
private:
    void dfs(vector<int>& candidates, vector<vector<int>>& result, vector<int>& path, int target, int start){
        if(target==0){
            result.push_back(path);
            return;
        }
        int previous=-1;//记录前一层的candidate[i]
        for(int i=start; i<candidates.size(); ++i){
            if(previous==candidates[i]) continue;//如果二者相等。表示以该数字为起始的排列已经计算过了，故跳过该重循环
            if(candidates[i]>target) return;
            previous = candidates[i];
            path.push_back(candidates[i]);
            dfs(candidates, result, path, target-candidates[i], i+1);//start变为i+1，表示每个数都只能出现一次
            path.pop_back();
        }
    }
};

• 思路
  • 给1中的代码加上两行，修改一行，保证每个数字只使用一次
    • 记录for循环中此次使用的candidate[i],如果下一次循环中candidate[i]与它数值相同，则跳过该层循环，因为以这个数为起点的排列已经全部计算过了
    • 将循环中递归调用dfs的函数参数修改一下，start变为i+1，表示该数只能出现一次

组合总和III

找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数，并且每种组合中不存在重复的数字。

说明：

所有数字都是正整数。
解集不能包含重复的组合。
示例 1:

输入: k = 3, n = 7
输出: [[1,2,4]]
示例 2:

输入: k = 3, n = 9
输出: [[1,2,6], [1,3,5], [2,3,4]]

class Solution {
public:
    vector<vector<int>> combinationSum3(int k, int n) {
        vector<vector<int>> result;
        vector<int> path;
        dfs(result, path, k, n, 1);
        return result;
    }
private:
	//k表示还需几个数，n表示还需多少值，start表示下一层递归的起点下标
    void dfs(vector<vector<int>>& result, vector<int>& path, int k, int n,int start){
        if(k==0 && n==0){
            result.push_back(path);
            return;
        }
        for(int i=start; i<10; ++i){
            if(i>n) return;
            path.push_back(i);
            dfs(result,path,k-1,n-i,i+1);
            path.pop_back();
        }
    }
};