代码随想Day 27 | 39. 组合总和、40.组合总和II、131.分割回文串

39. 组合总和 

本题是 集合里元素可以用无数次，那么和组合问题的差别 其实仅在于 startIndex上的控制，这道题目的递归控制中，因为可以重复选择，所以下一层的参数是i而不用i+1，详细代码如下：

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

剪枝：

这道题的剪枝不容易想到，先进行排序，对总集合排序之后，如果下一层的sum（就是本层的 sum + candidates[i]）已经大于target，就可以结束本轮for循环的遍历。

详细代码如下：

class Solution {
public:
    vector<int> path;
    vector<vector<int>> res;
    void backtrack(vector<int> candidates, int target, int sum, 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];
            backtrack(candidates, target, sum, i);
            path.pop_back();
            sum-=candidates[i];
        }
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        sort(candidates.begin(),candidates.end()); //排序
        backtrack(candidates,target,0,0);
        return res;
    }
};

40.组合总和II 

本题开始涉及到一个问题了：去重。注意题目中给我们集合是有重复元素的，那么求出来的组合有可能重复，但题目要求不能有重复组合。 

这道题去重的思路比较抽象，思想来自代码随想录：

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

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

这块比较抽象，如图：

我在图中将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<int> path;
    vector<vector<int>> res;
    void backtrack(vector<int> candidates, int target, int sum, int index, vector<bool>& used)
    {
        if(sum==target)
        {
            res.push_back(path);
            return ;
        }

        for(int i=index;i<candidates.size()&&sum+candidates[i]<=target;i++)
        {
            //去重 同一层已经用过，直接略过
            if(i>index&&candidates[i]==candidates[i-1]&&used[i-1]==false) continue;
            path.push_back(candidates[i]);
            sum+=candidates[i];
            used[i]=true;
            backtrack(candidates,target,sum,i+1,used);
            used[i]=false;
            sum-=candidates[i];
            path.pop_back();
        }
    }
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        vector<bool> used(candidates.size(),false);
        sort(candidates.begin(),candidates.end()); //排序重要
        backtrack(candidates,target,0,0,used);
        return res;
    }
};

 131.分割回文串  

这道题目和组合有相似之处，但是第一次遇到比较难理解，可以用索引来表示切割的地方，此外还需要注意string的语法问题，不能直接push_back一个字符，需要先取子串，然后进行push_back，这里还需要再研究，未剪枝的详细代码如下：（剪枝部分以后再涉及）

class Solution {
public:
    vector<string> path;
    vector<vector<string>> res;
    bool fuc(string s, int l, int r)
    {
        while(l<r)
        {
            if(s[l]!=s[r]) return false;
            l++;
            r--;
        }
        return true;
    }
    void backTracking(string s, int index)
    {
        //end
        if(index==s.size())
        {
            res.push_back(path);
            return;
        }
        for(int i=index;i<s.size();i++)
        {
            if(fuc(s,index,i))
            {
                string str = s.substr(index, i - index + 1); //此处语法重要
                path.push_back(str);
            }
            else continue; //不是回文，直接继续
            backTracking(s,i+1);
            path.pop_back();
        }
    }
    vector<vector<string>> partition(string s) {
        if(s.size()==0) return {};
        backTracking(s,0);
        return res;
    }
};