回溯与组合问题||

39.组合总和
回溯法，但是这里要注意的是避免重复计算组合，所以需要有函数中的startIndex来指定开

class Solution {
public:
    vector<int> path;
    vector<vector<int>> result;
    void tracking(const vector<int> &candidates,int target,int startIndex) {
        if(target==0) {
            result.push_back(path);
            return ;
        }
        for(int i=startIndex;i<candidates.size();i++) {
            if(target>=candidates[i]) {
                path.push_back(candidates[i]);
                tracking(candidates,target-candidates[i],i);
                path.pop_back();
            }
        }
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        result.clear();
        path.clear();
        tracking(candidates,target,0);
        return result;
    }
};

40.组合总和||
还是使用回溯法，但是这个题要去除重复组，因此需要有个判断的过程，同时确定结束条件的时候，要注意我们是通过排序和判断条件来去重的，因此越往后遍历的数字越大，这样会若目前的sum总值已经超过target，可以直接返回，否则，会超过题目的时间复杂度。（根据题目描述也知道，candidates的值都是正整数的）

class Solution {
public:
    vector<int> temp;
    vector<vector<int>> result;
    void tracking(vector<int>& candidates,int target,int sum,int startIndex) {
        if(sum==target) {
            result.push_back(temp);
            return ;
        }
        if(sum>target) return ;
        for(int i=startIndex;i<candidates.size();i++) {
            if(candidates[i]>target) break;
            temp.push_back(candidates[i]);
            tracking(candidates,target,sum+candidates[i],i+1);
            temp.pop_back();
            while(i+1<candidates.size()&&candidates[i+1]==candidates[i]) {
                i++;                  
            }
        };
    }
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(),candidates.end());
        // for(int i=0;i<candidates.size();i++) {
        //     cout<<candidates[i]<<" ";
        // }
        cout<<endl;
        result.clear();
        temp.clear();
        tracking(candidates,target,0,0);
        return result;
    }
};

131.分割回文字符串
按照我的想法来说，是需要判断指定字符是否是回文的，因为除了回溯之外还需要一个函数；

class Solution {
public:
    vector<vector<string>> result;
    vector<string> temp;
    bool IsSyn(string s,int start,int end) {
        for(;start<end;start++,end--) {
            if(s[start]!=s[end]) return false;
        }
        return true;
    }
    void tracking(string s,int start){
        if(start==s.length()) {
            result.push_back(temp);
        }
        for(int i=start;i<s.length();i++) {
            if(IsSyn(s,start,i)) {
                string t=s.substr(start,i-start+1);
                temp.push_back(t);
                tracking(s,i+1);
                temp.pop_back();
            }
        }
    }
    vector<vector<string>> partition(string s) {
        result.clear();
        temp.clear();
        tracking(s,0);
        return result;
    }   
};