算法题（day23）- 组合总和

39. 组合总和 - 力扣（LeetCode）

和组合相比，可以重复使用元素，则循环不用从startIndex开始，递归调用startIndex不从i + 1开始，是从 i 开始。

class Solution {
public:
    vector<vector<int>> ans;
    vector<int> path;
    vector<bool> flag;
    int sum;
    void back(vector<int>& candidates, int target, int sum, int startIndex){
        if(sum >= target){
            if(sum > target)    return;
            ans.push_back(path);
            return;
        }
        for(int i = startIndex; i < candidates.size(); i++){
            path.push_back(candidates[i]);
            sum += candidates[i];
            back(candidates, target, sum, i);
            sum -= candidates[i];
            path.pop_back();
        }
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        sum = 0;
        flag.resize(candidates.size(), false);
        back(candidates, target, sum, 0);
        return ans;
    }
};

40. 组合总和 II - 力扣（LeetCode）

 和组合1不同的地方在于，组合1没有相同的元素。对于不定长的要求，结束条件改变为总和判定。不能包含重复答案的方法：当 i > startIndex && candidates[i] == candidates[i - 1] 时，说明在同一层中，已经选取过相同的元素了。

class Solution {
public:
    vector<vector<int>> ans;
    vector<int> path;
    int sum;
    void combination(vector<int> &candidates, int target, int startIndex){
        if(sum >= target){
            if(sum > target)    return;
            ans.push_back(path);
            return;
        }
        for(int i = startIndex; i < candidates.size(); i++){
            if(i > startIndex && candidates[i] == candidates[i - 1]){
                continue;
            }
            path.push_back(candidates[i]);
            sum += candidates[i];
            combination(candidates, target, i + 1);
            sum -= candidates[i];
            path.pop_back();
        }
    }
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end());
        combination(candidates, target, 0);
        return ans;
    }
};

131. 分割回文串 - 力扣（LeetCode）

class Solution {
    vector<vector<string>> ans;
    vector<string> path;

    bool isP(string& s, int start, int end){
        while(start < end){
            if(s[start++] != s[end--])
                return false;
        }
        return true;
    }

    void back(string &s, int startIndex){
        if(startIndex >= s.size()){
            ans.push_back(path);
            return ;
        }
        for(int i = startIndex; i < s.size(); i++){
            if(isP(s, startIndex, i)){
                string str = s.substr(startIndex, i - startIndex + 1);
                path.push_back(str);
            }else{
                continue;
            }
            back(s, i + 1);
            path.pop_back();
        }
    }
public:
    vector<vector<string>> partition(string s) {
        back(s, 0);
        return ans;
    }
};