力扣第22天----第39题、第40题、第131题

力扣第22天----第39题、第40题、第131题

一、第39题–组合总和

​ 还是经典的回溯的套路----确定参数、返回来类型；确定返回条件；单层递归逻辑（for循环遍历+回溯）。

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backingtrace(vector<int>& candidates, int target, int sum, int startindex){
        if (sum > target) return;   // 大于的时候返回
        if (sum == target){        // 等于的时候，添加
            result.push_back(path);
            return;
        }
        sort(candidates.begin(), candidates.end()); 

        for (int i = startindex; i<candidates.size() && sum + candidates[i] <= target; i++){                       
            path.push_back(candidates[i]);   //path添加，sum更新
            sum += candidates[i];
            backingtrace(candidates, target, sum, i);  //注意，这里的startindex为i。因为允许重复。
            path.pop_back();                 //回溯---path、sum恢复。
            sum -= candidates[i];
        }
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        backingtrace(candidates, target, 0, 0);
        return result;
    }
};

二、第40题–组合总和II

​ 相比经典的回溯套路，多了个used数组，表示哪个变量被用过。首先对数组排序，保证相同数值的元素相邻，通过used数组，控制某些情况被剪枝掉----使用元素可以重复，但是结果中不能重复。这样就要求当前元素被使用时，前一个元素不能被使用，可以当前元素和前一元素都被使用。如果，当前元素被使用，而前一元素没有被使用，那么这种情况，前一元素的分支前做过，就可以去重了，而且题目中也要求不能重合。

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backingtrace(vector<int>& candidates, int target, int sum, int startindex, vector<bool> used){
        if(sum > target) return;
        if(sum == target) {
            result.push_back(path);
            return;
        }
        for (int i = startindex; i < candidates.size(); i++){
            if (i>0 && candidates[i] == candidates[i-1] && !used[i-1]) continue;
            path.push_back(candidates[i]);
            sum += candidates[i];
            used[i] = true;
            backingtrace(candidates, target, sum, i+1, used);
            path.pop_back();
            sum -= candidates[i];
            used[i] = false;
        }
    }

    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end());
        vector<bool> used(candidates.size() , false);
        backingtrace(candidates, target, 0, 0, used);
        return result;
    }
};

三、第131题–分割回文串

​ 这道题挺综合的，回溯+双指针判断回文。回溯的逻辑不好想，按照startindex的位置去构建树。譬如’aab’，构建为’a‘、’aa‘、’aab‘这三种，然后再逐渐递归遍历，每次递归时都进行判断，然后回溯。

​ 细节挺多，还要再好好想想，二刷再见。

class Solution {
public:
    vector<vector<string>> result;
    vector<string> v;

    void backingtrace(string s, int startindex){
        if (startindex >= s.size()) {
            result.push_back(v);
            return;
        }
        for (int i = startindex; i < s.size() ; i++){
            if (judge(s, startindex, i)) {
                v.push_back(s.substr(startindex, i - startindex +1));
            }
            else continue;
            backingtrace(s, i+1);
            v.pop_back();
        }
    }
    bool judge(string s, int startindex, int endindex){
        while( startindex <= endindex){
            if (s[startindex] != s[endindex]) return false;
            startindex++;
            endindex--;
        }
        return true;
    }

    vector<vector<string>> partition(string s) {
        backingtrace(s, 0);
        return result;
    }
};