代码随想录27|39组合总和、40组合总和Ⅱ以及131分割回文串

1 组合总和

39组合总和

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

进行排序方便剪枝去重

2 组合总和

40组合总和Ⅱ

可以利用数组去重（树层）

也可以利用startIndex去重

class Solution {
//去重关键：树层去重
public:
    vector<vector<int>> result;
    vector<int> path;
    
    //startIndex深度去重,used树层去重
    //void backtracking(vector<int>& candidates,int target, int sum,int startIndex,vector<bool> used){
    //     if(sum > target) return;
    //     if(sum == target){
    //         result.push_back(path);
    //         return;
    //     }
    //     for(int i = startIndex; i < candidates.size() && candidates[i] + sum <= target; i++){
    //         if(i>0 && candidates[i] == candidates[i-1] && used[i-1] == 0) continue;//used[i-1] == 1是深度
    //         path.push_back(candidates[i]);used[i] = 1;
    //         sum += candidates[i];
    //         backtracking(candidates,target,sum,i+1,used);
    //         used[i] = 0;
    //         sum -= candidates[i];
    //         path.pop_back();
            
    //     }
    // }


        //仅用startIndex去重
    void backtracking(vector<int>& candidates,int target, int sum,int startIndex){
        if(sum > target) return;
        if(sum == target){
            result.push_back(path);
            return;
        }
        for(int i = startIndex; i < candidates.size() && candidates[i] + sum <= target; i++){
            if(i>startIndex && candidates[i] == candidates[i-1]) continue;
            path.push_back(candidates[i]);
            sum += candidates[i];
            backtracking(candidates,target,sum,i+1);
         
            sum -= candidates[i];
            path.pop_back();
            
        }
    }

public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        if(candidates.size() == 0) return result;
        //vector<bool> used(candidates.size(),0);
        int sum = 0;
        sort(candidates.begin(),candidates.end());//排序为了让相邻的元素放在一起
        backtracking(candidates,target,sum,0);
        return result;
    }
};

3 分割回文串

131分割回文串

• 切割问题可以抽象为组合问题

• 如何模拟那些切割线（startIndex）

• 切割问题中递归如何终止（startIndex到头）

• 在递归循环中如何截取子串（[startIndex,i]）

• 如何判断回文

class Solution {
public:
    vector<string> path;
    vector<vector<string>> result; 
    bool isPalindrome(const string& s,int start,int end){
        while(start <= end){
            if(s[start] != s[end]) return false;
            start++;
            end--;
        }
        return true;
    }

    void backtracking(const string& s,int startIndex){
        //切割线到最后：startIndex即为切割线 
        if(startIndex == s.size()){
            result.push_back(path);
            return;
        }
        //切割的子串[startIndex,i]
        for(int i = startIndex; i < s.size(); i++){
             if(isPalindrome(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) {
        if(s.size() == 0) return result;
        backtracking(s,0);
        return result;
    }
};