代码随想录打卡Day 27| 回溯算法 part03-CSDN博客

本文链接：https://blog.csdn.net/lionelwhl/article/details/132036932

心得：递归用来纵向遍历，for循环用来横向遍历，

第一题组合总数避免答案相同顺序不同而重复的办法：在递归中用i作为startIndex，从而避免重复。因为这一类题目每个答案组的第一个数都是在外层for循环里的，所以只要在递归函数里更新i，就可以实现目的。

第二题的难点在于答案去重，因为candidate集合里有重复的数字。这里使用了vector<bool>的数组来记录某个数字是不是用过的。现将数组排序，这样相邻重复的数字在遍历到靠右数字是，前一个数的bool值就是false。是true说明还在上一个数的分支。

第三题的难点是如何分割字符串，用startIndex当作分割线。[startIndex，i]就是每一个字串。因为最外层for决定了第一个字的长度。

另外，判断一个字符串是不是回文，用双指针法啊！！！别之前学的做完就想不起来了

第一题、组合总数 LeetCode39 https://leetcode.cn/problems/combination-sum/

避免答案相同顺序不同而重复的办法：在递归中用i作为startIndex，从而避免重复。

因为这一类题目每个答案组的第一个数都是在外层for循环里的，所以只要在递归函数里更新i，就可以实现目的。

剪枝操作可以放在for循环里，从而避免进入下一个递归，减少复杂度。但是这样剪枝需要对candidate进行排序，以免漏掉前面的数大，后面数小的情况。

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    int sum = 0;
    void backtracking(vector<int>& candidates, int sum, int target, int startIndex){
        if(sum > target) return;
        if(sum == target){
            res.push_back(path);
            return;
        }
        for(int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++){
            path.push_back(candidates[i]);
            sum += candidates[i];
            //backtracking(candidates, sum, target, startIndex);
            backtracking(candidates, sum, target, i);
            sum -= candidates[i];
            path.pop_back();
        }
        return;
    }
    
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        res.clear();
        path.clear();
        sort(candidates.begin(), candidates.end());//剪枝后需要排序
        backtracking(candidates, 0, target, 0);   
        return res;
    }
};

第二题、组合总数-2 LeetCode 40 https://leetcode.cn/problems/combination-sum-ii/

本题的难点在于答案的去重。因为给定数组的数字是会重复的。

本题的难点在于区别2中：集合（数组candidates）有重复元素，但还不能有重复的组合。

一些同学可能想了：我把所有组合求出来，再用set或者map去重，这么做很容易超时！

所以要在搜索的过程中就去掉重复组合。

很多同学在去重的问题上想不明白，其实很多题解也没有讲清楚，反正代码是能过的，感觉是那么回事，稀里糊涂的先把题目过了。

这个去重为什么很难理解呢，所谓去重，其实就是使用过的元素不能重复选取。 这么一说好像很简单！

都知道组合问题可以抽象为树形结构，那么“使用过”在这个树形结构上是有两个维度的，一个维度是同一树枝上使用过，一个维度是同一树层上使用过。没有理解这两个层面上的“使用过” 是造成大家没有彻底理解去重的根本原因。

那么问题来了，我们是要同一树层上使用过，还是同一树枝上使用过呢？

回看一下题目，元素在同一个组合内是可以重复的，怎么重复都没事，但两个组合不能相同。

所以我们要去重的是同一树层上的“使用过”，同一树枝上的都是一个组合里的元素，不用去重。

为了理解去重我们来举一个例子，candidates = [1, 1, 2], target = 3，（方便起见candidates已经排序了）

强调一下，树层去重的话，需要对数组排序！

选择过程树形结构如图所示：

40.组合总和II

可以看到图中，每个节点相对于 39.组合总和 (opens new window)我多加了used数组，这个used数组下面会重点介绍。

如果candidates[i] == candidates[i - 1] 并且 used[i - 1] == false，就说明：前一个树枝，使用了candidates[i - 1]，也就是说同一树层使用过candidates[i - 1]。

此时for循环里就应该做continue的操作。

这块比较抽象，如图：

40.组合总和II1

我在图中将used的变化用橘黄色标注上，可以看出在candidates[i] == candidates[i - 1]相同的情况下：

used[i - 1] == true，说明同一树枝candidates[i - 1]使用过
used[i - 1] == false，说明同一树层candidates[i - 1]使用过

可能有的录友想，为什么 used[i - 1] == false 就是同一树层呢，因为同一树层，used[i - 1] == false 才能表示，当前取的 candidates[i] 是从 candidates[i - 1] 回溯而来的。

而 used[i - 1] == true，说明是进入下一层递归，去下一个数，所以是树枝上，如图所示：

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    int sum;
    
    void backtracking(vector<int>& candidates, int target, int sum, int startIndex, vector<bool>& used){
        if(sum == target){
            res.push_back(path);
            return;
        }
        for(int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++){
            // used[i - 1] == true，说明同一树枝candidates[i - 1]使用过
            // used[i - 1] == false，说明同一树层candidates[i - 1]使用过
            if(i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false){
                continue; //去重
            }
            path.push_back(candidates[i]);
            sum += candidates[i];
            used[i] = true;
            backtracking(candidates, target, sum, i + 1, used);
            sum -= candidates[i];
            path.pop_back();
            used[i] = false;
        }
        return;
    }

    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        vector<bool> used(candidates.size(), false);
        res.clear();
        path.clear();
        sort(candidates.begin(), candidates.end());
        backtracking(candidates, target, 0, 0, used);
        return res;
    }
};

这里直接用startIndex来去重也是可以的，就不用used数组了。

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;
        }
        for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) {
            // 要对同一树层使用过的元素进行跳过
            if (i > startIndex && candidates[i] == candidates[i - 1]) {
                continue;
            }
            sum += candidates[i];
            path.push_back(candidates[i]);
            backtracking(candidates, target, sum, i + 1); // 和39.组合总和的区别1，这里是i+1，每个数字在每个组合中只能使用一次
            sum -= candidates[i];
            path.pop_back();
        }
    }

public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        path.clear();
        result.clear();
        // 首先把给candidates排序，让其相同的元素都挨在一起。
        sort(candidates.begin(), candidates.end());
        backtracking(candidates, target, 0, 0);
        return result;
    }
};

第三题、分割回文串 LeetCode131 https://leetcode.cn/problems/palindrome-partitioning/

回溯三部曲

递归函数参数

全局变量数组path存放切割后回文的子串，二维数组result存放结果集。（这两个参数可以放到函数参数里）

本题递归函数参数还需要startIndex，因为切割过的地方，不能重复切割，和组合问题也是保持一致的。

在回溯算法：求组合总和（二） (opens new window)中我们深入探讨了组合问题什么时候需要startIndex，什么时候不需要startIndex。

代码如下：

vector<vector<string>> result;
vector<string> path; // 放已经回文的子串
void backtracking (const string& s, int startIndex) {

递归函数终止条件

131.分割回文串

从树形结构的图中可以看出：切割线切到了字符串最后面，说明找到了一种切割方法，此时就是本层递归的终止条件。

那么在代码里什么是切割线呢？

在处理组合问题的时候，递归参数需要传入startIndex，表示下一轮递归遍历的起始位置，这个startIndex就是切割线。

所以终止条件代码如下：

void backtracking (const string& s, int startIndex) {
    // 如果起始位置已经大于s的大小，说明已经找到了一组分割方案了
    if (startIndex >= s.size()) {
        result.push_back(path);
        return;
    }
}

单层搜索的逻辑

来看看在递归循环中如何截取子串呢？

在for (int i = startIndex; i < s.size(); i++)循环中，我们定义了起始位置startIndex，那么 [startIndex, i] 就是要截取的子串。

首先判断这个子串是不是回文，如果是回文，就加入在vector<string> path中，path用来记录切割过的回文子串。

代码如下：

for (int i = startIndex; i < s.size(); i++) {
    if (isPalindrome(s, startIndex, i)) { // 是回文子串
        // 获取[startIndex,i]在s中的子串
        string str = s.substr(startIndex, i - startIndex + 1);
        path.push_back(str);
    } else {                // 如果不是则直接跳过
        continue;
    }
    backtracking(s, i + 1); // 寻找i+1为起始位置的子串
    path.pop_back();        // 回溯过程，弹出本次已经添加的子串
}

注意切割过的位置，不能重复切割，所以，backtracking(s, i + 1); 传入下一层的起始位置为i + 1。

class Solution {
public:
    vector<vector<string>> res;
    vector<string> path;

    bool isPalindrome(const string& s, int start, int end){
        for(int i = start, j = end; i < j; i++, j--){
            if(s[i] != s[j]){
                return false;
            }
        }
        return true;
    }

    void backtracking(const string&s, int startIndex){
        // 如果起始位置已经大于s的大小，说明已经找到了一组分割方案了
        if(startIndex >= s.size()){
            res.push_back(path);
            return;
        }
        for(int i = startIndex; i < s.size(); i++){
            if(isPalindrome(s, startIndex, i)){
                // 获取[startIndex,i]在s中的子串
                string str = s.substr(startIndex, i - startIndex + 1);
                path.push_back(str);
            }
            else{
                continue;
            }
            backtracking(s, i + 1);// 寻找i+1为起始位置的子串
            path.pop_back();
        }
        return;
    }
    
    vector<vector<string>> partition(string s) {
        res.clear();
        path.clear();
        backtracking(s, 0);
        return res;
    }
};