LeetCode | C++ 39. 组合总和、40.组合总和II、131.分割回文串

39. 组合总和

注意本题和77.组合 、216.组合总和III 的一个区别是：本题元素为可重复选取的。

区别仅在于 startIndex 的控制上， 因为可以对一个元素重复选取， i 就不用 + 1了

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

40.组合总和II

本题相较于39题而言，难点在于，给出的集合中有重复元素，但是还不能有重复的组合。

需要对给出的集合进行排序，目的是让相同的元素相邻，注：相同的元素中第一个遍历的时候，会包括后面相同元素遍历的所有情况，所以，需要在树层层面进行去重，即对后面相同的元素进行 跳过。

在这里引入了一个used bool 类型数组，对于使用过的元素标记为true, 未使用过的标记为 false. 该数组的目的去确定这个是在树层上还是在树枝上， 假如相同元素的 i - 1 位置 为false, i的 位置为 true, 则判断为树层， 若i - 1 和 i 的位置上 都为true，则判断为树枝。

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

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

131.分割回文串

切割问题，用startIndex 去代表切割线

i 表示当前切割点，startIndex 表示上一个切割点， [startIndex, i] 构成切割的子串

判断一个字符串是否为回文串，即从字符串左右两边搜索，去判断是否相等即可。

class Solution {
public:
    bool isPalindrome(const string& s, int left, int right) {
        while (right >= left) {
            if (s[left] == s[right]) {
                left++;
                right--;
            }
            else {
                return false;
            }
        }
        return true;
    }
    vector<string> path;
    vector<vector<string>> result;
    void backtracking(const 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);
                backtracking(s, i + 1);
                path.pop_back();
            }
        }
        return;
    }
    vector<vector<string>> partition(string s) {
        path.clear();
        result.clear();
        backtracking(s, 0);
        return result;
    }
};