刷题记录|Day27 ● 39. 组合总和 ● 40.组合总和II ● 131.分割回文串

最新推荐文章于 2024-05-30 20:15:33 发布

null_one

最新推荐文章于 2024-05-30 20:15:33 发布

阅读量213

点赞数

分类专栏： leedcode刷题文章标签：算法数据结构动态规划

本文链接：https://blog.csdn.net/null_one/article/details/129485527

版权

leedcode刷题专栏收录该内容

45 篇文章 0 订阅

订阅专栏

39. 组合总和

题目描述

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。

candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。

对于给定的输入，保证和为 target 的不同组合数少于 150 个。

示例 1：

输入：candidates = [2,3,6,7], target = 7
输出：[[2,2,3],[7]]
解释：
2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。
7 也是一个候选， 7 = 7 。
仅有这两种组合。

示例 2：

输入: candidates = [2,3,5], target = 8
输出: [[2,2,2,2],[2,3,3],[3,5]]

示例 3：

输入: candidates = [2], target = 1
输出: []

提示：

1 <= candidates.length <= 30
2 <= candidates[i] <= 40
candidates 的所有元素 互不相同
1 <= target <= 40

解题思路

本题和77.组合，216.组合总和III 的区别是：本题没有数量要求，可以无限重复，但是有总和的限制，所以间接的也是有个数的限制。

本题搜索的过程抽象成树形结构如下：
在这里插入图片描述
注意图中叶子节点的返回条件，因为本题没有组合数量要求，仅仅是总和的限制，所以递归没有层数的限制，只要选取的元素总和超过target，就返回！

回溯三部曲

确定参数数量

这里依然是定义两个全局变量，二维数组result存放结果集，数组path存放符合条件的结果。（这两个变量可以作为函数参数传入）

首先是题目中给出的参数，集合candidates, 和目标值target。

此外我还定义了int型的sum变量来统计单一结果path里的总和，其实这个sum也可以不用，用target做相应的减法就可以了，最后如何target==0就说明找到符合的结果了，但为了代码逻辑清晰，我依然用了sum。

vector<vector<int>> result;
vector<int> path;
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();++i)
        {
            path.push_back(candidates[i]);
            sum += candidates[i];
            backtracking(candidates,target,sum,i);
            sum -= candidates[i];
            path.pop_back();
        }

代码结合


class Solution {
private:
    
    vector<vector<int>> result;

    vector<int> path;
    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();++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) {
        result.clear();
        path.clear();
        backtracking(candidates,target,0,0);
        return result;
        

    }
};

40.组合总和II

题目描述

给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用一次。

**注意：**解集不能包含重复的组合。

示例 1:

输入: candidates = [10,1,2,7,6,1,5], target = 8,
输出:
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]

示例 2:

输入: candidates = [2,5,2,1,2], target = 5,
输出:
[
[1,2,2],
[5]
]

提示:

1 <= candidates.length <= 100
1 <= candidates[i] <= 50
1 <= target <= 30

解题思路

代码整合


class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;

    void backtracking(vector<int> &candidates, int target, int sum, int startIndex,vector<int>&used)
    {
        if(sum > target )
        {
            return;
        }
        else 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] == false) {
                 continue;
            }

            used[i] = 1;
            path.push_back(candidates[i]);
            sum += candidates[i];
            backtracking(candidates,target,sum,i+1,used);
            used[i] = 0;
            sum -= candidates[i];
            path.pop_back();

            

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


    }
};

131.分割回文串

题目描述

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。

回文串 是正着读和反着读都一样的字符串。

示例 1：

输入：s = "aab"
输出：[["a","a","b"],["aa","b"]]

示例 2：

输入：s = "a"
输出：[["a"]]

提示：

1 <= s.length <= 16
s 仅由小写英文字母组成

解题思路

本题这涉及到两个关键问题：

切割问题，有不同的切割方式
判断回文

相信这里不同的切割方式可以搞懵很多同学了。

这种题目，想用for循环暴力解法，可能都不那么容易写出来，所以要换一种暴力的方式，就是回溯。

一些同学可能想不清楚回溯究竟是如何切割字符串呢？

我们来分析一下切割，其实切割问题类似组合问题。

例如对于字符串abcdef：

组合问题：选取一个a之后，在bcdef中再去选取第二个，选取b之后在cdef中再选取第三个…。
切割问题：切割一个a之后，在bcdef中再去切割第二段，切割b之后在cdef中再切割第三段…。

感受出来了不？

所以切割问题，也可以抽象为一棵树形结构，如图：
在这里插入图片描述

回溯三部曲

确定参数

在这里插入代码片

确定终止条件

从树形结构的图中可以看出：切割线切到了字符串最后面，说明找到了一种切割方法，此时就是本层递归的终止条件。

那么在代码里什么是切割线呢？

在处理组合问题的时候，递归参数需要传入startIndex，表示下一轮递归遍历的起始位置，这个startIndex就是切割线。

所以终止条件代码如下：

void backtracking (const string& s, int startIndex) {
    // 如果起始位置已经大于s的大小，说明已经找到了一组分割方案了
    if (startIndex >= s.size()) {
        result.push_back(path);
        return;
    }
}

确定单次循环的逻辑

来看看在递归循环中如何截取子串呢？

在for (int i = startIndex; i < s.size(); i++)循环中，我们定义了起始位置startIndex，那么 [startIndex, i] 就是要截取的子串。

首先判断这个子串是不是回文，如果是回文，就加入在vector<string> path中，path用来记录切割过的回文子串。

代码如下：

for (int i = startIndex; i < s.size(); i++) {
    if (isPalindrome(s, startIndex, i)) { // 是回文子串
        // 获取[startIndex,i]在s中的子串
        string str = s.substr(startIndex, i - startIndex + 1);
        path.push_back(str);
    } else {                // 如果不是则直接跳过
        continue;
    }
    backtracking(s, i + 1); // 寻找i+1为起始位置的子串
    path.pop_back();        // 回溯过程，弹出本次已经填在的子串
}

代码整合

class Solution {
  vector<string> path;
  vector<vector<string>> result;
  bool isPalindrome(string s, int i, int j)
  {
      for(int start = i , end = j ; start<end; ++start,--end)
      {
          if(s[start]!=s[end])
            {
                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 (isPalindrome(s, startIndex, i)) { // 是回文子串
        // 获取[startIndex,i]在s中的子串
                string str = s.substr(startIndex, i - startIndex + 1);
                path.push_back(str);
            } else {                // 如果不是则直接跳过
                    continue;
            }
        backtracking(s, i + 1); // 寻找i+1为起始位置的子串
        path.pop_back();  
        }
    }
public:
    vector<vector<string>> partition(string s) {
        backtracking(s,0);
        return result;

    }
};