04. 组合总和

news2025/1/13 2:59:56

1.题目链接：

39. 组合总和

2.解题思路：

2.1.题目要求：

给定一个“无重复数组candidates”和一个“目标和target” ，要求在给定数组candidates 的范围内，输出和等于目标和target 的组合，此组合元素可重复。

示例 1：输入：candidates = [2,3,6,7], target = 7, 所求解集为： [ [7], [2,2,3] ]

2.2.思路：

模拟成一个n叉树，终止条件变成搜索的和等于目标和

2.3.回溯三部曲：

2.3.1.确定回溯函数参数

定义两个全局变量，一个一维数组path 暂时存储搜集的结果，一个二维数组result 存储最终结果集

参数除了默认的数组candidates 和目标和target ，还有用于记录搜集递归过程值的sum，还有一个startIndex？感觉用不上这玩意，待会试试看

vector<vector<int>> result;
vector<int> path;
void backtracking(vector<int>& candidates, int target, int sum, int startIndex) {

2.3.2.确定终止条件

当搜集数字的总和sum 等于目标和target 的时候，可以记录并返回了

同时因为没有层数要求，会不断递归寻找合适的值，所以需要一个条件来限制层数，也就是当总和sum已经大于目标和target的时候。

if (sum > target) return;

if (sum == target) {
      result.push_back(path);
      return;
}

2.3.3.确定单层遍历逻辑

这里递归到下一层搜索不用像之前那样+1，因为题目说，组合可以重复。

for (int i = startIndex; i < candidates.size(); i++) {
      sum += candidates[i];
      path.push_back(candidates[i]);
      backtracking(candidates, target, sum, i); // 不用i+1了，表示可以重复读取当前的数
      sum -= candidates[i];
      path.pop_back();
}

2.4.总代码：

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& candidates, int target, int sum, int startIndex) {
        if (sum > target) {
            return;
        }
        if (sum == target) {
            result.push_back(path);
            return;
        }

        for (int i = startIndex; i < candidates.size(); i++) {
            sum += candidates[i];
            path.push_back(candidates[i]);
            backtracking(candidates, target, sum, i); // 不用i+1了，表示可以重复读取当前的数
            sum -= candidates[i];
            path.pop_back();
        }
    }
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        result.clear();
        path.clear();
        backtracking(candidates, target, 0, 0);
        return result;
    }
};

2.5.剪枝优化

如图所示，当sum > target的时候就会返回，如果可以提前预测下一层的sum 会不会大于 target，如果大于就跳过，这样就可以省去一层遍历了，剪枝成功。

剪枝可以在for循环范围作改动，在范围那提前预测，加上 && sum + candidates[i] <= target ，在预测下一层sum不大于target的前提下继续递归。

注意，剪枝前记得，要先排序，不排序 sum + candidates[i] <= target的代码预测可能不准，因为，如果一开始下一层就遇见很大的数的话（超过target），那这一整层都会被剪掉，这样就缺少了很多组合。

 for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++)

剪枝代码如下:

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& candidates, int target, int sum, int startIndex) {
        if (sum == target) {
            result.push_back(path);
            return;
        }

        // 如果 sum + candidates[i] > target 就终止遍历
        for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) {
            sum += candidates[i];
            path.push_back(candidates[i]);
            backtracking(candidates, target, sum, i);
            sum -= candidates[i];
            path.pop_back();

        }
    }
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        result.clear();
        path.clear();
        sort(candidates.begin(), candidates.end()); // 需要排序
        backtracking(candidates, target, 0, 0);
        return result;
    }
};