Day23 回溯法3 | LeetCode 39. 组合总和, 40. 组合总和 II, 131. 分割回文串

LeetCode 39. 组合总和

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;

    void backTracking(vector<int>& candidates, int target, int startIndex){
        if (target < 0) {
            return;
        }
        if (target == 0) {
            result.push_back(path);
            return;
        }

        for (int i = startIndex; i < candidates.size(); i++) {
            path.push_back(candidates[i]);
            backTracking(candidates, target - candidates[i], i);
            path.pop_back();
        }
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        backTracking(candidates, target, 0);
        return result;
    }
};

LeetCode 40. 组合总和 II

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;

    void backTracking(vector<int>& candidates, int target, int startIndex) {
        if (target < 0) {
            return;
        }
        if (target == 0) {
            result.push_back(path);
        }
        for (int i = startIndex; i < candidates.size(); i++) {
            if (i > startIndex && candidates[i] == candidates[i - 1]){
                continue;
            }
            path.push_back(candidates[i]);
            backTracking(candidates, target - candidates[i], i + 1);
            path.pop_back();
        }

    }

    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {

        sort(candidates.begin(), candidates.end(), less<int>());
        backTracking(candidates, target, 0);
        return result;
    }
};

LeetCode 131. 分割回文串

class Solution {
public:
    vector<vector<string>> result;
    vector<string> path;
    
    void backTracking(string& s, int startIndex){
        if (startIndex >= s.size()) {
            result.push_back(path);
            return;
        }
        
        for (int i = startIndex; i < s.size(); i++) {
            if (isPalindrome(s, startIndex, i)) {
                string str = s.substr(startIndex, i - startIndex + 1);
                path.push_back(str);
            }else {
                continue;
            }
            backTracking(s, i + 1);
            path.pop_back();
        }

    }

    bool isPalindrome(string& str, int begin, int end) {
        for (int i = begin, j = end; i < j; i++, j--) {
            if (str[i] != str[j]) {
                return false;
            }
        }
        return true;
    }

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