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

最新推荐文章于 2024-11-01 17:00:11 发布

Cynic_TianLiang

最新推荐文章于 2024-11-01 17:00:11 发布

阅读量52

点赞数

分类专栏：代码随想录文章标签：算法 leetcode c++ Powered by 金山文档

本文链接：https://blog.csdn.net/elven_prophecy/article/details/129488279

版权

代码随想录专栏收录该内容

30 篇文章 0 订阅

订阅专栏

文章介绍了使用回溯法解决三道编程题：39.组合总和（元素可重复选取）、40.组合总和II（元素不可重复选取）以及131.分割回文串。每道题都涉及对给定数组的处理和递归回溯策略，通过排序数组和避免重复来优化解题效率。

摘要由CSDN通过智能技术生成

题目链接：39. 组合总和

本题和77.组合 (opens new window)、216.组合总和III (opens new window)的一个区别是：本题元素为可重复选取的。

代码如下：

class Solution {
private:
vector<vector<int>> result;
vector<int> path;
void backTacking(vector<int>& candidates,int sum, int target,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]);
        backTacking(candidates,sum,target,i);
        sum-=candidates[i];
        path.pop_back();
    }
     
     
}
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        result.clear();
        path.clear();
        sort(candidates.begin(),candidates.end());
        backTacking(candidates,0,target,0);
        return result;
    }
};

题目链接：40.组合总和II

candidates 中的每个数字在每个组合中只能使用一次且解集不能包含重复的组合，故需要加上以下约束条件。

if(i >0&& candidates[i]== candidates[i -1]&& used[i -1]==false)
{
    continue;
}

整体代码如下：

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backTacking(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]);
            //used[i]=true;
            backTacking(candidates,target,sum,i+1);
            //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);
        result.clear();
        path.clear();
        sort(candidates.begin(),candidates.end());
        backTacking(candidates,target,0,0);
        return result;

    }
};

题目链接：131.分割回文串

class Solution {
private:
vector<vector<string>> result;
vector<string> path;
vector<vector<bool>> isPalindrom;
void backTacking(string& s,int startIndex)
{
    if(startIndex>=s.size())
    {
        result.push_back(path);
        return;
    }
    for(int i=startIndex;i<s.size();i++)
    {
        if(isPalindrom[startIndex][i])
        {
            string str=s.substr(startIndex,i-startIndex+1);
            path.push_back(str);
            
        }
        else
        continue;
        backTacking(s,i+1);
        path.pop_back();
    }

}
void computePalindrom(string& s)
{
    isPalindrom.resize(s.size(),vector<bool>(s.size(),false));
    for(int i=s.size()-1;i>=0;i--)
    for(int j=i;j<s.size();j++)
    {
        if(j==i) isPalindrom[i][j]=true;
        else if(j-i==1) isPalindrom[i][j]=(s[i]==s[j]);
        else isPalindrom[i][j]=(s[i]==s[j]&&isPalindrom[i+1][j-1]);
       //  else {isPalindrom[i][j] = (s[i] == s[j] && isPalindrom[i+1][j-1]);}
    }
}
public:
    vector<vector<string>> partition(string s) {
        result.clear();
        path.clear();
        computePalindrom(s);
        backTacking(s,0);
        return result;
    }
};