代码随想录算法训练营第二十天|39. 组合总和、40.组合总和II、131.分割回文串

39. 组合总和

给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。candidates 中的数字可以无限制重复被选取。

这道题与之前不同的是，我们可以考虑重复的数。

什么时候需要startindex？

如果是一个集合来求组合的话，就需要startIndex；如果是多个集合取组合，各个集合之间相互不影响，那么就不用。

class Solution {
public:
    vector<vector<int>> result;
    vector<int> res;
    void backtracking(vector<int>& candidates, int target, int sum, int startindex){
        if(sum>target){
            return;
        }
        if(sum==target){
            result.push_back(res);
            return;
        }
        for(int i=startindex; i<candidates.size(); i++){ //candidates[0]到[size-1]
            sum+=candidates[i];
            res.push_back(candidates[i]);
            backtracking(candidates, target, sum, i);
            res.pop_back();
            sum-=candidates[i];
        }
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        result.clear();
        res.clear();
        backtracking(candidates, target, 0, 0);//要从0开始
        return result;
    }
};

剪枝的过程：

for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++)

大于target了以后，直接不遍历。

• 时间复杂度: O(n * 2^n)，注意这只是复杂度的上界，因为剪枝的存在，真实的时间复杂度远小于此
• 空间复杂度: O(target)

40.组合总和II

给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。candidates 中的每个数字在每个组合中只能使用一次。

与上一道题的区别是，这道题的candidates中每个数字在每个组合中只能使用一次。且数字是有重复的。

本题的难点在于区别2中：集合（数组candidates）有重复元素，但还不能有重复的组合。

元素在同一个组合内是可以重复的，怎么重复都没事，但两个组合不能相同。所以我们要去重的是同一树层上的“使用过”，同一树枝上的都是一个组合里的元素，不用去重。

我们多加了一个used数组。

vector<bool> used(candidates.size(), false);

如果candidates[i] == candidates[i - 1] 并且 used[i - 1] == false，就说明：前一个树枝，使用了candidates[i - 1]，也就是说同一树层使用过candidates[i - 1]。

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

• 时间复杂度: O(n * 2^n)
• 空间复杂度: O(n)

131.分割回文串

给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。

返回 s 所有可能的分割方案。

使用双指针法，判断回文串。

class Solution {
public:
    vector<vector<string>> result;
    vector<string> path;
    bool IsPalindrome(string& s, int start, int end){
        int back=end, front=start;
        for(; front<back; front++, back--){
            if(s[front]!=s[back]){
                return false;
            }
        }
        return true;
    }
    //一个集合来求组合的话，就需要startIndex
    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)){
                path.push_back(s.substr(startindex, i-startindex+1));
            }else{
                continue;//如果不满足直接跳过这个i，到下一个i
            }
            backtracking(s, i+1);
            path.pop_back();
        }
    }
    vector<vector<string>> partition(string s) {
        result.clear();
        path.clear();
        backtracking(s, 0);
        return result;
    }
};

• 时间复杂度: O(n * 2^n)
• 空间复杂度: O(n^2)

注意切割过的位置，不能重复切割，所以，backtracking(s, i + 1); 传入下一层的起始位置为i + 1.