代码随想录算法训练营第二十七天

代码随想录算法训练营第二十七天

一、39.组合总和

思路

​ 该题在思路上基本上能想出来，但是在代码实现上出现了疏忽，导致结果一直不对，归根到底还是回溯算法没理解到位。剪枝优化的方式也想到了，但是实现上没想到可以写在for循环的条件判断上。

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

        }
        return ;
    }
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        result.clear();
        path.clear();
        sort(candidates.begin(), candidates.end());
        backtracking(candidates, target,0, 0);
        return result;
    }
};

二、40.组合总和2

思路

​ 这道题目和39.组合总和 (opens new window)如下区别：

1. 本题candidates 中的每个数字在每个组合中只能使用一次。
2. 本题数组candidates的元素是有重复的，而39.组合总和 (opens new window)是无重复元素的数组candidates

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

​ 想到用排序，但是排序后如何区分该元素是否用过，是主要难点。

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& candidates, int target, int sum, int startindex){
        if(sum == target){
            result.push_back(path);
            return ;
        }

        for(int i = startindex; i < candidates.size() && sum + candidates[i] <=target; i++){
            // 排除同一树层使用过的元素
            if (i > startindex && candidates[i] == candidates[i - 1]) {
                continue;
            }
            sum += candidates[i];
            path.push_back(candidates[i]);
            backtracking(candidates, target, sum, i+1);
            sum -= candidates[i];
            path.pop_back();
        }
    }
public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        result.clear();
        path.clear();
        sort(candidates.begin(), candidates.end());
        backtracking(candidates, target, 0, 0);
        return result;
    }
};

三、131.分割回文串

思路：

​ 该题思路能够想到，但是没能想到采用i和startindex的区别当作双指针选取substr。以及终止的条件没想好。

class Solution {
private:
    vector<vector<string>> result;
    vector<string> path;
    bool backstring(const string& c, int start, int end){
        for(int i = start, j = end; i <j; i++,j--){
            if(c[i] != c[j])
                return false;
        }
        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++){
            if(backstring(s, startindex, i)){
                path.push_back(s.substr(startindex, i - startindex + 1));
            }
            else
                continue;
            backtracking(s, i+1);
            path.pop_back();
        }
    }
public:
    vector<vector<string>> partition(string s) {
        result.clear();
        path.clear();
        backtracking(s, 0);
        return result;
    }
};

四、总结

​ 要继续深入理解回溯算法的思想，弄清楚 i 和startindex 的区别。