代码随想录第29天：回溯算法part3｜leetcode39组合总和｜leetcode40组合总和2｜leetcode131 分割回文串

leetcode39：组合总和

文章讲解：leetcode39

leetcode40：组合总和2

文章讲解：leetcode40

leetcode131：分割回文串

文章讲解：leetcode131

目录

1，leetcode39 组合总和：

2，leetcode40 组合总和2

3，leetcode131 分割回文串

---

1，leetcode39 组合总和：

这道题和之前的那个组合总和区别在于这个数字是可以重复利用的，

这道题有个限制了，以下代码跑不通的：

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backtracing(vector<int>& candidates, int target, int sum, int startindex){
        if(sum == target){
            result.push_back(path);
            return;
        }
        for(int i = startindex;i<candidates.size();i++){
            sum = sum + candidates[i];
            path.push_back(candidates[i]);
            backtracing(candidates, target, sum, i);
            sum = sum - candidates[i];
            path.pop_back();

        }
    
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        backtracing(candidates,target, 0, 0);
        return result;
    }
};

递归深度太深，如果不做剪枝的话会爆栈，通不过。

我能想到的剪枝操作就是，既然都是非负数，那么如果sum已经大于target，就不需要再做搜索了。

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backtracing(vector<int>& candidates, int target, int sum, int startindex){
        if(sum == target){
            result.push_back(path);
            return;
        }
        if(sum > target){
            return;
        }//剪枝
        for(int i = startindex;i<candidates.size();i++){
            sum = sum + candidates[i];
            path.push_back(candidates[i]);
            backtracing(candidates, target, sum, i);
            sum = sum - candidates[i];
            path.pop_back();

        }
    
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        backtracing(candidates,target, 0, 0);
        return result;
    }
};

代码随想录的剪枝起点也是这样，但是他是直接在for上做剪枝，这样的好处是就不需要进入下一层递归直接跳过。

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

又学到一种写法。

2，leetcode40 组合总和2

这道题与上一道的区别是，candidate里面有了重复元素。并且重复元素不能随便去除，因为比如

candidate=1，2，2，3 target = 4 这时13，22都是答案，因此不能直接对candidate去重。

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

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

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

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

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

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

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

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

回溯去重复的逻辑就是，不使用上一层已经使用过的元素。因此used数组也加入了回溯套餐中。used数组是针对位置判断是否使用过的。

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;

    void backtracking(vector<int>& candidates, int target, int sum, int startIndex, vector<bool>& used) {
        if (sum == target) {
            result.push_back(path);
            return;
        }
        for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) {
            if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) {
                continue;
            }
            sum += candidates[i];
            path.push_back(candidates[i]);
            used[i] = true;
            backtracking(candidates, target, sum, i + 1, used); 
            used[i] = false;
            sum -= candidates[i];
            path.pop_back();
        }
    }

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

这道题有意思的地方在于，在树上操作的时候，提供了一种方法在同层之间传递信息。这是很有趣的地方。

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;
    }
};

总体而言，还是使用used数组清晰一些。

3，leetcode131 分割回文串

这道题看到后就明确肯定是个递归。切割一个出来后，在剩下的字符串再重复切的操作。回文的判断方法倒是会，但是怎么切割怎么停止，剪枝，这个确实想不明白了。

class Solution {
private:
    vector<vector<string>> result;
    vector<string> path; // 放已经回文的子串
    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++) {
            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(); // 回溯过程，弹出本次已经添加的子串
        }
    }
    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;
    }
public:
    vector<vector<string>> partition(string s) {
        backtracking(s, 0);
        return result;
    }
};

很奇妙，看上去很难，但实际的答案仍然没有离开回溯的模版。

这道题和剩下的剪枝部分过两天完整刷完回溯后再看看。