回溯算法练习——3、组合总和（C++和Python描述）

来源：代码随想录
本题的力扣链接：https://leetcode-cn.com/problems/combination-sum/

1、题目描述：

2、思路：

本题和求组合那道题的区别是：本题没有数量要求，可以⽆限重复，但是有总和的限制，所以间接的也是有个数的限制。本题搜索的过程抽象成树形结构如下：

这里我需要多说一句：
这道题和以前的组合问题有区别，以前的组合问题是不能重复的，而本题相同元素是可以重复。从树上看，每层的第一个节点使用全部的元素，而之后的节点都以此减去前面的元素。
因此，我们只需在for循环那里修改即可（因为，横向for遍历，纵向递归）。

依然按递归三部曲：

3、代码：

3.1 python代码：

• （1）我自己首先想到的是：有重复组合的集合，然后在保存的时候排序，保证只加入一次组合的集合。但是这种方法显然时间复杂度高，自己想到的，记录一下罢了，下面是代码：

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        res = [] # 存放结果集合
        path = [] # 收集路径上的元素
        def backtracking(index):
            if sum(path) == target:
                temp = path.copy()
                temp.sort() # 把符合条件的排列从小打到排序
                if temp not in res: # 过滤重复的排列，也就是一个组合
                    res.append(temp)
                return
            for i in range(len(candidates)):
                if sum(path) < target:
                    path.append(candidates[i]) # 收集路径上的元素(处理)
                    backtracking(index+1) # 递归
                    path.pop() # 回溯
                else: # 终止横向遍历
                	break
        
        backtracking(0)
        return res

• （2）直接生成不重复的组合：注意startIndex这个参数。在组合中，startIndex这个参数就是控制不重复选择元素的

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        res = [] # 存放结果集合
        path = [] # 收集路径上的元素
        def backtracking(startIndex):
            if sum(path) == target:
                res.append(path.copy())
                return
            for i in range(startIndex, len(candidates)):
                if sum(path) < target: # 这个判断就是一个剪枝操作
                    path.append(candidates[i]) # 收集路径上的元素(处理)
                    backtracking(i) # 递归，不用i+1表示可重复取当前元素
                    path.pop() # 回溯
                else: # 终止横向遍历
                	break
        
        backtracking(0)
        return res

3.2 C++代码：

• （1）未剪枝的代码：

class Solution {
private:
    vector<vector<int>> res; // 存放最后的结果集合
    vector<int> path; // 收集树路径上的有效值
    void backtracking(vector<int>& candidates, int target, int startIndex, int sum){
        if(sum > target){
            return;
        }
        if(sum == target){
            res.push_back(path);
            return;
        }
        for(int i = startIndex; i < candidates.size(); i++){
            sum += candidates[i];
            path.push_back(candidates[i]); // 收集路径上的元素
            backtracking(candidates, target, i, sum); // 不使用i+1，表示可以重复使用元素
            sum -= candidates[i]; // 回溯
            path.pop_back(); // 回溯
        }
    }

public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        // sort(candidates.begin(), candidates.end()); // 需要排序（剪枝需要）
        backtracking(candidates, target, 0, 0);
        return res;

    }
};

• （2）剪枝之后的代码：需要先排序，因为按从小到大排序，只要sum大于target了，那后面的就肯定大于了，要是不排序，那就不一定了。

class Solution {
private:
    vector<vector<int>> res; // 存放最后的结果集合
    vector<int> path; // 收集树路径上的有效值
    void backtracking(vector<int>& candidates, int target, int startIndex, int sum){
        if(sum > target){
            return;
        }
        if(sum == target){
            res.push_back(path);
            return;
        }
        for(int i = startIndex; i < candidates.size() && (sum + candidates[i]) <= target; i++){
            sum += candidates[i];
            path.push_back(candidates[i]); // 收集路径上的元素
            backtracking(candidates, target, i, sum); // 不使用i+1，表示可以重复使用元素
            sum -= candidates[i]; // 回溯
            path.pop_back(); // 回溯
        }
    }

public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end()); // 需要排序，再剪枝
        backtracking(candidates, target, 0, 0);
        return res;

    }
};

4、总结：

本题依然是组合问题，不同与最基本组合问题的是，本题的组合元素是可以重复的。
要特别注意startIndex这个参数，这个参数的作用是：startIndex来控制for循环的起始位置，那什么时候需要使用startIndex这个参数呢？
答：
1）求一个集合的组合，肯定就要用startIndex参数；
2）而要是多个集合取组合，各个集合之间相互不影响，就不需要用startIndex参数了。