代码随想录算法训练营第二十七天| 39. 组合总和、 40.组合总和II、 131.分割回文串

组合总数

题目链接：力扣

这题和之前题目的区别在于，本题没有数量要求，可以无限重复的取某一元素，但是对元素的总和有限制，这就说明了递归的限制不在于层数，而是选取元素的总和超过target就返回

 终止条件为两种情况：
sum>target 或 sum=target

同时，本题和之前几天做过的题目相比，本题的元素可以重复选取。
这就意味着在for循环中 调用递归函数时，不再使用i+1，而是直接使用i。
其他的按照套路进行即可。

class Solution {
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {

        backtracking(candidates,target,0,0);
        return result;        
    }

    vector<int> Path;
    vector<vector<int>>result;
    void backtracking(vector<int>& candidates, int target, int sum,int index)
    {
       if(sum > target)
        return;

        if(sum == target)
        {
            result.push_back(Path);
            return;
        }

        for(int i=index;i<candidates.size();i++)
        {
            sum += candidates[i];
            Path.push_back(candidates[i]);
            backtracking(candidates,target,sum, i);
            Path.pop_back();
            sum -= candidates[i];
        }
    }
};

组合总和II

题目链接：力扣

这题和之前题目的区别是，这道题给出的元素中有重复元素，而解集中要求不能包含重复的组合。
如果使用map或set，将会很容易导致超时。
这里涉及到一个知识点：回溯算法中的去重。

所谓去重，其实就是使用过的元素不能重复选取。 
“使用过”在这个树形结构上是有两个维度的，一个维度是同一树枝上使用过，一个维度是同一树层上使用过。
回看一下题目，元素在同一个组合内是可以重复的，怎么重复都没事，但两个组合不能相同。
所以我们要去重的是同一树层上的“使用过”，同一树枝上的都是一个组合里的元素，不用去重。

去重的关键代码就在于此，由于for循环内部就是对树的横向遍历，所以若遇到
candidates[i] == candidates[i - 1]
则说明已经处理过前一个元素，该元素可以跳过。

            if(i>index && candidates[i]==candidates[i-1])

            continue;

下面给出完整代码：

class Solution {
public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end());
        backtracking(candidates, target, 0,0);
        return result;

    }

    vector<int>Path;
    vector<vector<int>>result;

    void backtracking(vector<int>& candidates, int target, int sum, int index)
    {
        if(sum > target)
        return; 

        if(sum == target)
        {
            result.push_back(Path);
            return;
        }

        for(int i = index; i<candidates.size();i++)
        {
            if(i>index && candidates[i]==candidates[i-1])
            continue;
            
            sum += candidates[i];
            Path.push_back(candidates[i]);
            backtracking(candidates,target,sum, i+1);
            sum -= candidates[i];
            Path.pop_back();
        }
    }
};

分割回文串

题目链接：力扣

 递归用来纵向遍历，for循环用来横向遍历，切割线（就是图中的红线）切割到字符串的结尾位置，说明找到了一个切割方法。

class Solution {
public:
    vector<vector<string>> partition(string s) {

        backtracking(s,0);
        return result;

    }

    vector<string>Path;
    vector<vector<string>> result;

    void backtracking(string s, int index)
    {
        if(index >= s.size())
        result.push_back(Path);


        for(int i=index; i<s.size();i++)
        {
            if(isPalindrome(s,index,i))  //判断index~i范围内的字符串是否是回文
           {
               string temp = s.substr(index, i-index+1);
               Path.push_back(temp);
           } 
           else
           {
               continue;
           }
            
           backtracking(s,i+1);
           Path.pop_back();
        }

    }


    bool isPalindrome(string s,int start, int end)   //判断是否是回文串
    {
        while(start < end)
        {
            if(s[start] == s[end])
            {
                start++;
                end--;
            }
            else
            return false;
        }
        return true;
    }
};