代码随想录算法训练营第二十三天|回溯算法part02

39. 组合总和

在一个集合中，可以多次使用同一个元素，找到组合总和为target的组合。
可以重复使用同一个元素就是将之前组合类型题目中递归参数startIndex不要+1。

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;
    }
};

40.组合总和II

在一个集合中，一个元素只能使用一次，找到组合总和为target的组合，并且答案中不能有重复的组合。
这道题目涉及了去重问题。树层去重，树枝不去重。

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) {
            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());
        backtracking(candidates, target, 0);
        return result;
    }
};

131.分割回文串

一个字符串可以看成一个集合，切割的字符串范围是$[startIndex,i]$。

class Solution {
public:
    vector<string> path;
    vector<vector<string>> result;
    bool isPalindrome(string s, int begin, int end) {
        // [startIndex, i]
        while (begin <= end) {
            if (s[begin] != s[end]) 
                return false;
            begin++;
            end--;
        }
        return true;
    }
    void backtracking(string s, int startIndex) {
        if (startIndex == s.size()) {
            result.push_back(path);
            return;
        }
        for (int i = startIndex; i < s.size(); ++i) {
            // [startIndex, i]
            if (!isPalindrome(s, startIndex, i))
                continue;
            string ss = s.substr(startIndex, i - startIndex + 1);
            path.push_back(ss);
            backtracking(s, i + 1);
            path.pop_back();
        }
    }
    vector<vector<string>> partition(string s) {
        backtracking(s, 0);
        return result;
    }
};