今天是回溯算法学习的第二天，主要的学习内容包括：1.组合问题的重复使用 2.组合问题的去重 3.分割问题的处理方法。

39. 组合总和

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

这个组合问题的特点是，集合内的元素可以重复使用。与前面组合问题的区别在于，在每一次回溯中，不是从i+1的位置开始穷举，而是从i开始穷举。这样就满足元素重复使用的要求。对于剪枝操作，这个题的做法是如果求和的结果已经大于目标值，后面的操作就不需要了，可以直接进行回溯了。具体代码实现如下所示：
 

class Solution {
public:
vector<int> vec;
vector<vector<int>> result;
    void backtracking(vector<int>& candidates,int target,int sum,int startindex)
    {
        if(sum==target)
        {
            //sort(vec.begin(),vec.end());
            //result.erase(unique(result.begin(),result.end()),result.end());
            result.push_back(vec);
            return;
        }
        if(sum>target)
        {
            return;
        }
        for(int i=startindex;i<candidates.size()&&sum+candidates[i]<=target;i++)
        {
            vec.push_back(candidates[i]);
            backtracking(candidates,target,sum+candidates[i],i);
            vec.pop_back();
        }
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        sort(candidates.begin(),candidates.end());
        backtracking(candidates,target,0,0);
        return result;
    }
};

40.组合总和II

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

这个组合问题的难点在于有重复值的元素，但是每个元素只能使用一次。这就出现了一个问题，比如数组【1,1,2】，目标为3，直接回溯的话会出现两个【1,2】的组合，但这样是不允许的。所以我们需要对结果进行一个去重操作。

去重操作的逻辑是这样的，随想录将这种去重命名为树层去重。还是用【1,1,2】为例，在同一层的遍历过程中，当第一个1已经和后面的数递归完成了组合时，第二个1再做组合一定会出现相同的结果，那么我们将第二个1的递归结果进行去重。判断的逻辑是这个数和相邻元素相同并且递归过程中相邻元素没有被使用。下面的图可以更好的解释这一过程。

所以这道题就是需要在组合问题的基础上加上对同一层相同元素的去重。具体实现代码如下：

class Solution {
public:
vector<int> vec;
vector<vector<int>> result;
void backtracking(vector<int>& candidates,int target,int sum,int startindex,vector<bool>& used)
{
    if(sum>target) return;
    if(sum==target)
    {
        result.push_back(vec);
        return;
    }
    for(int i=startindex;i<candidates.size()&&sum+candidates[i]<=target;i++)
    {
        if(i>0&&candidates[i]==candidates[i-1]&&used[i-1]==0) continue;
        vec.push_back(candidates[i]);
        used[i]=1;
        backtracking(candidates,target,sum+candidates[i],i+1,used);
        used[i]=0;
        vec.pop_back();
    }
}
    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;
    }
};

 也可以使用startindex进行直接的去重，但是使用used数组会更加容易理解。
 

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

131.分割回文串

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

这个题目是一个难题。题目的要求是对一个字符串进行切割，被切割的子串都要满足是一个回文子串。需要求解所有的切割方案。

那么这个题目的做法是使用startindex作为切割点，当startindex与原字符串长度相同，就可以返回所有的切割结果；在for循环遍历过程中，对于每一个i需要判断是否是回文子串，把正确的结果放入一个数组中，并进行递归和回溯。具体代码实现如下：
 

class Solution {
public:
    vector<string> vec;
    vector<vector<string>> result;
    void backtracking(string& s,int startindex)
    {
        if(startindex>=s.size())
        {
            result.push_back(vec);
            return;
        }
        for(int i=startindex;i<=s.size();i++)
        {
            if(ispar(s,startindex,i)==0) continue;
            string temp=s.substr(startindex,i-startindex+1);
            vec.push_back(temp);
            backtracking(s,i+1);
            vec.pop_back();
        }
        
    }
    bool ispar(string s,int start,int end)
    {
        int mid=(end-start)/2;
        for(int i=0;i<=mid;i++)
        {
            if(s[start+i]!=s[end-i]) return false;
        }
        return true;
    }
    vector<vector<string>> partition(string s) {
        backtracking(s,0);
        return result;

    }
};