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

题目链接：39. 组合总和 - 力扣（LeetCode）

文章讲解：代码随想录

错误解答：

class Solution {
public:
    vector<vector<int>>ans;
    vector<int>path;
    int sumofVector(const vector<int>v){
        int sum=0;
        for(auto x:v){
            sum+=x;
        }
        return sum;
    }
    
    void backTracking(vector<int>& candidates,int target){
        if(sumofVector(path)==target){
            ans.push_back(path);
            return;
        }
        for(int i=0;i<candidates.size();i++){
            path.push_back(candidates[i]);
            backTracking(candidates,target);
            path.pop_back();

        }

    }

    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        backTracking(candidates,target);
        return ans;
    }
};

错误地方：

边界条件。 会导致无限循环

另一个 可能出现 223 322这样的情况 

正确解答：

class Solution {
public:
    vector<vector<int>>ans;
    vector<int>path;
    int sumofVector(const vector<int>v){
        int sum=0;
        for(auto x:v){
            sum+=x;
        }
        return sum;
    }
    
    void backTracking(vector<int>& candidates,int target,int startIndex){
        if(sumofVector(path)==target){
            ans.push_back(path);
            return;
        }
        if(sumofVector(path)>target){return;}         //剪枝
        for(int i=startIndex;i<candidates.size();i++){
            path.push_back(candidates[i]);
            backTracking(candidates,target,i);    //允许重复出现
            path.pop_back();

        }

    }

    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        backTracking(candidates,target,0);
        return ans;
    }
};

40.组合总和II

题目链接：40. 组合总和 II - 力扣（LeetCode）

文章讲解：代码随想录

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

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

        backTracking(candidates,target,0,0);
        return ans;
    }
};

 错误之处：会出现重复的答案，没有去重。

正确解答：

class Solution {
public:
    vector<vector<int>>ans;
    vector<int>path;
    void backTracking(vector<int>& candidates,int target,int sum,int startindex,vector<bool>& used){
        if(sum==target){
            ans.push_back(path);
        }
        if(sum>target){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,target,sum,i+1,used);
            sum-=candidates[i];
            used[i]=false;
            path.pop_back();
        }

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

 if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) {
                continue;
            }//这里去重  

used[i - 1] == false为什么是false的解释 

考虑112 目标值等于3

对于第二个1 前一个1没有被使用 并且第二个1与第一个1相等，此时不考虑这种情况 continue

131.分割回文串

题目链接：131. 分割回文串 - 力扣（LeetCode）

文章讲解：代码随想录

思路：

判断startIndex到i之间的子串是否是回文串 如果是加入 继续更新startindex 继续下一轮判断

class Solution {
public:
    bool IsHui(string s){
        string reverS=s;
        reverse(reverS.begin(),reverS.end());
        for(int i=0;i<s.size();i++){
            if(s[i]!=reverS[i]) return false;
        }
        return true;
    }
    vector<string>path;
    vector<vector<string>>ans;
    void backTracking(string s,int startIndex){
        if(startIndex>=s.size()){
            ans.push_back(path);
            return;
        }
        for(int i=startIndex;i<s.size();i++){
            string ss(s.begin()+startIndex,s.begin()+i+1);
            if(IsHui(ss)){
                path.push_back(ss);
            }else{continue;}
            backTracking(s,i+1);
            path.pop_back();
        }
    }

    vector<vector<string>> partition(string s) {
        path.clear();
        ans.clear();
        backTracking(s, 0);
        return ans; 
    }
};