二刷代码随想录训练营Day 23|39. 组合总和、40.组合总和II、131.分割回文串

1.组合总和

题目链接/文章讲解：代码随想录

视频讲解：带你学透回溯算法-组合总和（对应「leetcode」力扣题目：39.组合总和）| 回溯法精讲！_哔哩哔哩_bilibili

代码：回溯法

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

note：这里可以选取重复元素，然后我就陷入了迷茫。因为虽然可以选取重复元素，但是组合问题也是要去重的，这又明显和前面的不能选取重复元素的题目不同。

这里其实还是使用startIndex来去重，不过因为可以选取重复元素，startIndex从i开始而不是从i+1开始。

代码：剪枝优化

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

note：这里的剪枝优化是指，因为candidates的元素都是正数，因此target减去一个正数只会越来越小。我们先将candidates里的元素进行排序。在for循环中，直接加入剪枝的条件——target-candidates[i] >= 0就好了。

在求和问题中，排序之后加剪枝是常见的套路！

2.组合总和2

题目链接/文章讲解：代码随想录

视频讲解：回溯算法中的去重，树层去重树枝去重，你弄清楚了没？| LeetCode:40.组合总和II_哔哩哔哩_bilibili

代码：

class Solution {
private:
    vector<int> path;
    vector<vector<int>> result;
    void backtracking(vector<int> candidates,int target,int startIndex,vector<bool>& used){
        if(target == 0){
            result.push_back(path);
            return;
        }
        for(int i = startIndex; i < candidates.size() && target - candidates[i] >= 0; i++){
            if(i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false){
                continue;
            }
            used[i] = true;
            path.push_back(candidates[i]);
            backtracking(candidates,target - candidates[i],i + 1,used);
            path.pop_back();
            used[i] = false;
        }
    }
public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        vector<bool> used(candidates.size(),false);
        sort(candidates.begin(),candidates.end());
        backtracking(candidates,target,0,used);
        return result;
    }
};

 note：这里要进行树枝去重。

如图所示，我们为了去重，应该避免在同一层取相同的元素，而可以在树枝上选取相同的元素（因为这算是一个集合里的元素）。为了实现这一目的，我们选用了一个数组used，在把这个元素添加进path的同时，将其对应的used[i]变为true。（前提是给数组candidates里的元素进行排序，不然没有办法把相同的元素挨在一起。）

这样做之后，如果发现当前元素和上一个元素相同，且上一个元素对应的used[i] == false，就说明此时应该进行树枝去重continue了。

ps：for循环写习惯了，老是把i从0开始写，应该从startIndex开始。

3.分割回文串

代码随想录

视频讲解：带你学透回溯算法-分割回文串（对应力扣题目：131.分割回文串）| 回溯法精讲！_哔哩哔哩_bilibili

代码：

class Solution {
private:
    vector<vector<string>> result;
    vector<string> path;
    void backtracking(const string &s,int startIndex){
        if(startIndex >= s.size()){
            result.push_back(path);
            return;
        }
        for(int i = startIndex; i < s.size(); i++){
            if(isCheck(s,startIndex,i)){
                string str = s.substr(startIndex, i - startIndex + 1);
                path.push_back(str);
            }else{
                continue;
            }
            backtracking(s,i + 1);
            path.pop_back();
        }
    }
    bool isCheck(const string &s,int start,int end){
        while(start < end){
            if(s[start] != s[end]){
                return false;
            }
            start++;
            end--;
        }
        return true;
    }
public:
    vector<vector<string>> partition(string s) {
        backtracking(s,0);
        return result;
    }
};

 note：这里就是用startIndex来模拟切割线，每次切割的部分是【startIndex,i】