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

原创已于 2025-04-08 15:50:09 修改 · 169 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #leetcode #数据结构 #学习 #回溯

于 2025-04-07 23:14:13 首次发布

代码随想录算法训练营专栏收录该内容

30 篇文章

订阅专栏

一、39 组合总和

class Solution {
private:
    vector<vector<int>>result;//保存结果集
    vector<int>path;//保存单一结果
    void backtraking(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();i++){
            path.push_back(candidates[i]);
            sum += candidates[i];
            backtraking(candidates,target,sum,i);
            sum -= candidates[i];
            path.pop_back();
        }
    }
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        backtraking(candidates,target,0,0);
        return result;
    }
};

二、40 组合总和||

class Solution {
private:
    vector<vector<int>>result;
    vector<int>path;
    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();i++){
        if(i>0&&candidates[i]==candidates[i-1]&&used[i-1]==0)//去重
            continue;
        path.push_back(candidates[i]);
        sum += candidates[i];
        used[i] = true;
        backtracking(candidates,target,sum,i+1,used);
        used[i] = false;
        sum -= candidates[i];
        path.pop_back();
    }
}
public:
    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 result;
    }
};

三、131 分割回文串

class Solution {
private:
    vector<vector<string>>result;
    vector<string>path;
    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);//复制子串，从startindex开始，复制i-startindex+1个字符
                path.push_back(str);
            }
            else
                continue;
            backtracking(s,i+1);
            path.pop_back();
        }
    }
    bool isPalindrome(const string s,int begin,int end){
        for(int i=begin,j=end;i<j;i++,j--){//双指针，一个在头，一个在尾，如果头尾所指元素一样则为回文
            if(s[i]!=s[j])
                return false;
        }
        return true;
    }
public:
    vector<vector<string>> partition(string s) {
        backtracking(s, 0);
        return result;
    }
};