代码随想录训练营 Day27 回溯算法part03 39. 组合总和● 40.组合总和II● 131.分割回文串

39. 组合总和 

题目链接：39. 组合总和 - 力扣（LeetCode）

文章链接：代码随想录 (programmercarl.com)

视频链接：Leetcode:39. 组合总和讲解

这道题与之前两道组合题的区别在于这道题并没有限制数字的个数，所以这道题并不能确定构成的树的深度。 

同时，这道题规定了，同一个数组可以无限制重复被选举，也就是每次递归都可以从它本身的元素开始递归，所以代码如下：

backtracking(candidates, target, sum, i)//之前都是i+1

总代码如下：

class Solution {
public:
    vector<int> path;
    vector<vector<int>> result;
    void backtracking(vector<int>& candidates,int targetsum,int sum,int index)
    {
        if(sum>targetsum) return;
        if(sum==targetsum){
            result.push_back(path);
            return;
        } 
        for(int i=index;i<candidates.size();i++)
        {
            path.push_back(candidates[i]);
            backtracking(candidates,targetsum,sum+candidates[i],i);//每个元素可重复选取
            path.pop_back();
        }
        return;
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        backtracking(candidates,target,0,0);
        return result;
    }
};

40.组合总和II

 题目链接：40. 组合总和 II - 力扣（LeetCode）

文章链接：代码随想录 (programmercarl.com)

视频链接：回溯算法中的去重，树层去重树枝去重，你弄清楚了没？| LeetCode:40.组合总和II

这道题又有了新的条件——解集不能包含重复的组合

有人可能会问，实例1中的[1,1,6]不就有重复数字嘛，我们需要知道这两个1是因为原来的数组中有两个1，他们只是元素值相同而已，元素是不同的。

如何理解去重？

首先我们将数组从小到大排序，这样相同元素值的元素就挨在了一起了。当我们递归相同元素值中第一个元素时，其实就把后面元素值相同的元素也一起递归了一遍，之后的元素就不要再递归了，直接跳过就好，这样就能避免重复的组合。

所以我们需要有一个bool数组来记录，每个元素是否使用过。如果使用过，就代表正在树枝遍历，没有使用过（因为回溯会使true重新变为false），就代表正在数层便利（for循环），那么就需要用continue跳过。

去重代码如下： 

for(int i=index;i<candidates.size()&& sum + candidates[i] <= target;i++){
            if(i>0&&candidates[i]==candidates[i-1]&&used[i-1]==false){//去重
                continue;
            }
            path.push_back(candidates[i]);
            used[i]=true;
            backtracking(candidates,target,sum+candidates[i],i+1,used);
            used[i]=false;
            path.pop_back();
        }

总代码如下：

class Solution {
public:
    vector<int> path;
    vector<vector<int>> result;
    void backtracking(vector<int>& candidates,int target,int sum,int index,vector<bool> used){
        if(sum==target){
            result.push_back(path);
            return;
        }
        for(int i=index;i<candidates.size()&& sum + candidates[i] <= target;i++){//去重
            if(i>0&&candidates[i]==candidates[i-1]&&used[i-1]==false){
                continue;
            }
            path.push_back(candidates[i]);
            used[i]=true;
            backtracking(candidates,target,sum+candidates[i],i+1,used);
            used[i]=false;//回溯操作，让bool重新变为false
            path.pop_back();
        }
        return;
    }
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(),candidates.end());
        vector<bool> used(candidates.size(),false);//bool类型判断元素是否被使用过，判断此时是树枝遍历还是树层遍历。
        backtracking(candidates,target,0,0,used);
        return result;
    }
};

131.分割回文串

 题目链接：131. 分割回文串 - 力扣（LeetCode）

文章链接：代码随想录 (programmercarl.com)

视频链接：131.分割回文串

 这道题略难，第一次接触，确实有一些吃力，在此分享一些自己的想法。

首先就是判断回文串，可以采用双指针法

bool judgepalindrome(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;
    }

接着是如何分割字符串。这一点其实和组合题很像，分割线就是每一次，backtracking中的index，我们通过for循环找到回文子串，然后将之输入进path中。

按图理解可能容易一些（代码随想录）

总代码如下：

class Solution {
public:
    vector<string> path;
    vector<vector<string>> result;
    bool judgepalindrome(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(string& s,int index){
        if(index>=s.size()){//当index超过s.size()，那就说明切割线切到了字符串最后面
            result.push_back(path);
            return;
        }
        for(int i=index;i<s.size();i++){//[startIndex, i] 就是要截取的子串。
            if(judgepalindrome(s,index,i))
            {
                string str=s.substr(index,i-index+1);
                path.push_back(str);
            }
            else continue;
            backtracking(s,i+1);
            path.pop_back();
        }
        return;
    }
    vector<vector<string>> partition(string s) {
        backtracking(s,0);
        return result;
    }
};

 Day26打卡成功，耗时3小时，去重和分割的方法很有意思，一知半解，再接再厉！