Day27（Day26休息）|39. 组合总和 |40.组合总和II |131.分割回文串

可能今日衰败，明日苦涩，后日没有一丁点的希望，但你坚持，后面的日子不是比前面的日子充满生机与希望吗？

39. 组合总和

非剪枝版

class Solution {
private:
        vector<int> temp;
        vector<vector<int>> result;
        void backtarcking(vector<int>& candidates,int target, int sum, int index)
        {
            if(sum > target) return;
            if(sum == target)
            {
                result.push_back(temp);
                return;
            }

            for(int i=index;i<candidates.size();i++)//关键的index
            {
                sum+=candidates[i];
                temp.push_back(candidates[i]);
                backtarcking(candidates,target,sum,i);
                sum-=candidates[i];//注意减的操作
                temp.pop_back();
            }
        }
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        if(candidates.size()==0) return result;
         backtarcking(candidates,target,0,0);
        return result;
    }
};

剪枝版

class Solution {
private:
        vector<int> temp;
        vector<vector<int>> result;
        void backtarcking(vector<int>& candidates,int target, int sum, int index)
        {
            if(sum > target) return;
            if(sum == target)
            {
                result.push_back(temp);
                return;
            }
            //加上剪枝条件 如果 sum+candidates[i]>sum 结束这一层for遍历返回上一层
            //则写成 成立 条件是 sum+candidates[i]<=sum!
            for(int i=index;i<candidates.size()&&sum+candidates[i]<=target;i++)//关键的index
            {
                sum+=candidates[i];
                temp.push_back(candidates[i]);
                backtarcking(candidates,target,sum,i);
                sum-=candidates[i];//注意减的操作
                temp.pop_back();
            }
        }
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        if(candidates.size()==0) return result;
        //但是想想我们sort数组下，前面小的数组组合已经大于target了，后面有必要去在递归吗？
        //例如2 3 5 target=4 {2，2} {2，3} {2，5}，在{2，3}时我们就结束这一层的遍历！不必再向下{2，5}
        sort(candidates.begin(),candidates.end());
         backtarcking(candidates,target,0,0);
        return result;
    }
};

40.组合总和II

这里与39.组合总和最大的不同就是要去重了。
（index+1即可）在day25中有表现！

class Solution {
private:
    vector<int>temp;
    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(temp);
            return;
        }
        for(int i=index;i<candidates.size()&&sum+candidates[i]<=target;i++)//index的重要性,因为用了sort，所以顺便剪枝下
        {
            if(i>index&&candidates[i]==candidates[i-1])//这样判断条件？是 i > index//已经老判断了
                continue;//用过的元素continue,但是这里要经过sort排序！例如：1 3 6 1 2
                //sort后 1 1 2 3 6，相同的排到一起消除！ 
            sum+=candidates[i];
            temp.push_back(candidates[i]);
            backtracking(candidates,target,sum,i+1);
            sum-=candidates[i];
            temp.pop_back();
        }
    }
public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        if(candidates.size()==0)return result;
        sort(candidates.begin(),candidates.end());
        backtracking(candidates,target,0,0);
        return result;
    }
};

131.分割回文串

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。
回文串 是正着读和反着读都一样的字符串。
思路有点像判断数组组合

class Solution {
private:
    vector<vector<string>>result;//二维字符串数组
    vector<string> temp;//字符串数组
    void backtracking(string &s, int index)
    {
        if(index == s.size() )//表示index位于最后切割字母的后面，例如：aab，index位于b后为3 ps:s[2]=b!
        {
            result.push_back(temp);//一位字符串数组存入二维字符串数组中
            return;
        }
        for(int i=index;i<s.size();i++)
        {
            if(judgereverse(s,index,i))//回文判断
            {
                string str=s.substr(index,i-index+1);//i-index+1为长度！
                    temp.push_back(str);
            } else {
                continue; //如果不是回文字符串，长度+1，判断
            }
            backtracking(s,i+1);//是回文字符串我们就向下递归搜索
            temp.pop_back();//回溯
        }
    }
    bool judgereverse(string s,int start,int end)//判断是否为回文串，是否存入数组
    {
        for(int i=start,j=end;i<j;i++,j--)//这个判断条件巧妙i<j一个的时候根本不判断返回true!!
        {
            if(s[i]!=s[j])
            return false;
        }
        return true;
    }
public:
    vector<vector<string>> partition(string s) {
        if(s.size()==0) return result;
        backtracking(s,0);
        return result;
    }
};