代码随想录day23

39.组合总和

    vector<vector<int>> result;
    vector<int> path;
    void backtrack(vector<int>& candidates, int target, int start){
        if(target == 0){
            result.push_back(path);
            return;
        }else if(target < 0){
            return;
        }
        for(int i = start; i < candidates.size(); i++){
            path.push_back(candidates[i]);
            backtrack(candidates, target-candidates[i], i);
            path.pop_back();
        }
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        result.clear();
        path.clear();
        if(candidates.size() == 0){
            return result;
        }
        sort(candidates.begin(), candidates.end()); 
        backtrack(candidates, target, 0);
        return result;
    }

40.组合总和ii

//需理解used数组的用途，区分同一树枝使用过和同一树层使用过

    vector<vector<int>> result;
    vector<int> path;
    void backtrack(vector<int>& candidates, int target, 
                    int start,vector<bool>& used){
        if(target < 0){
            return;
        }
        if(target == 0){
            result.push_back(path);
            return;
        }
        for(int i = start; i < candidates.size(); i++){
            if (i > 0 && candidates[i] == candidates[i - 1] 
                && used[i - 1] == false) 
            {
                continue;
            }
            path.push_back(candidates[i]);
            used[i] = true;
            backtrack(candidates, target-candidates[i], i+1, used);
            used[i] = false;
            path.pop_back();
        }
    }
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        result.clear();
        path.clear();
        vector<bool> used(candidates.size(), false);
        if(candidates.size()==0){
            return result;
        }
        sort(candidates.begin(), candidates.end());
        backtrack(candidates, target, 0, used);
        return result;
    }

131.分割回文串，需二刷

//第一种写法，采用回溯+双指针判断，主要理解回溯来分割字符串的用法

    vector<vector<string>> result;
    vector<string> path;
    bool isHuiwen(string s, int start, int end){
        for(int i = start, j = end; i < j; i++,j--){
            if(s[i] != s[j]){
                return false;
            }
        }
        return true;
    }
    void backtracking(string s, int start){
        if(start >= s.size()){
            result.push_back(path);
            return;
        }
        for(int i = start; i < s.size(); i++){
            if(isHuiwen(s, start,i)){
                string r = s.substr(start, i - start + 1);
                path.push_back(r);
            }else{
                continue;
            }
            backtracking(s, i+1);
            path.pop_back();
        }
    }
    vector<vector<string>> partition(string s) {
        result.clear();
        path.clear();
        backtracking(s, 0);
        return result;
    }

//写法2://判断回文时使用动态规划

    vector<vector<string>> result;
    vector<string> path;
    vector<vector<bool>> isHuiwenFlag;
    void compulteHuiwen(string s){
        isHuiwenFlag.resize(s.size(), vector<bool>(s.size(), false));
        for(int i = s.size()-1; i >= 0; i--){
            for(int j = i; j < s.size(); j++){
                if(i == j){
                    isHuiwenFlag[i][j] = true;
                }else if(j - i == 1){
                    isHuiwenFlag[i][j] = (s[i] == s[j]);
                }else{
                    isHuiwenFlag[i][j] = ((s[i] == s[j]) && isHuiwenFlag[i+1][j-1]);
                }
            }
        }
    }
    
    void backtracking(string s, int start){
        if(start >= s.size()){
            result.push_back(path);
            return;
        }
        for(int i = start; i < s.size(); i++){
            if(isHuiwenFlag[start][i]){
                string r = s.substr(start, i - start + 1);
                path.push_back(r);
            }else{
                continue;
            }
            backtracking(s, i+1);
            path.pop_back();
        }
    }
    vector<vector<string>> partition(string s) {
        result.clear();
        path.clear();
        compulteHuiwen(s);
        backtracking(s, 0);
        return result;
    }