编程题-组合总和（中等）_编程题组合-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_43287713/article/details/145607662

题目：

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。

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

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

解法一（笔者回溯思想）：

对于这类寻找所有可行解的题，我们都可以尝试用【搜索回溯】的方法来解决。我们定义递归函数声明为kyk(vector<int> candidates, int target, int i, vector<vector<int>>& results, vector<int> result, int length)，表示当前在candidates数组的第i位，还剩target要组合，已经组合的列表为results，目前正在组合的数组为result。回溯的终止条件为target≤0或者candidates数组被全部用完。每次我们都将先判断是否满足回溯的终止条件，若满足则直接进行跳出函数，若不满足终止条件，则执行下一步骤的回溯，如下为笔者代码：

class Solution {
public:
    void kyk(vector<int> candidates, int target, int i, vector<vector<int>>& results, vector<int> result, int length){
        if(target==0){
            results.push_back(result);
            return;
        }
        if(candidates[i]>target){
            return;
        }
        else{
            for(int j=i; j<length; j++){
                result.push_back(candidates[j]);
                target = target-candidates[j];
                kyk(candidates, target, j, results, result, length);
                result.pop_back();
                target = target+candidates[j];
            }
        }
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        int length = candidates.size();
        sort(candidates.begin(), candidates.end());
        vector<vector<int>> results;
        vector<int> result;
        kyk(candidates, target, 0, results, result, length);
        return results;
    }
};

解法二（官方回溯思想）：

定义递归函数dfs(target, combine, idx)表示当前在candidates数组的第idx位，还剩target要组合，已经组合的列表为combine。递归的终止条件为target≤0或者candidates数组被全部用完。那么在当前的函数中，每次可以选择跳过不用第idx个数，即执行dfs(target, combine, idx+1)。也可以选择使用第idx个数，即执行dfs(target-candidates[idx], combine, idx)，注意到每个数字可以被无限制重复选择，因此搜索的下标仍为idx。

更形象化地说，如果我们将整个搜索过程用一个树来表达，每次的搜索都会延伸出两个分叉，直到递归的终止条件，这样我们就能不重复且不遗漏地找到所有可行解，如下为实现代码：

class Solution {
public:
    //vector<int>& combine和vector<vector<int>>& ans均设置为引用形式
    void dfs(vector<int>& candidates, int target, vector<vector<int>>& ans, vector<int>& combine, int idx) {
        if (idx == candidates.size()) {
            return;
        }
        if (target == 0) {
            ans.emplace_back(combine);
            return;
        }
        // 直接跳过，进行对下一个idx+1数组索引元素的判断，防止for循环导致内存超限
        dfs(candidates, target, ans, combine, idx + 1);
        // 选择当前数,其中target - candidates[idx] >= 0为回溯算法剪枝条件
        if (target - candidates[idx] >= 0) {
            combine.emplace_back(candidates[idx]);
            dfs(candidates, target - candidates[idx], ans, combine, idx);
            combine.pop_back();
        }
    }

    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        vector<vector<int>> ans;
        vector<int> combine;
        dfs(candidates, target, ans, combine, 0);
        return ans;
    }
};

时间复杂度：O(S)，其中 S 为所有可行解的长度之和。从分析给出的搜索树我们可以看出时间复杂度取决于搜索树所有叶子节点的深度之和，即所有可行解的长度之和。在这题中，我们很难给出一个比较紧的上界，我们知道 O(n×2n) 是一个比较松的上界，即在这份代码中，n 个位置每次考虑选或者不选，如果符合条件，就加入答案的时间代价。但是实际运行的时候，因为不可能所有的解都满足条件，递归的时候我们还会用 target−candidates[idx]≥0 进行剪枝，所以实际运行情况是远远小于这个上界的。空间复杂度：O(target)。除答案数组外，空间复杂度取决于递归的栈深度，在最差情况下需要递归 O(target) 层。