算法工程师第二十天（39. 组合总和 40.组合总和II 131.分割回文串）

最新推荐文章于 2024-10-05 22:19:52 发布

LookCodes

最新推荐文章于 2024-10-05 22:19:52 发布

阅读量771

点赞数 18

文章标签：算法

本文链接：https://blog.csdn.net/rgz147123/article/details/140687083

版权

参考文献代码随想录

一、组合总和

给你一个 无重复元素 的整数数组 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

问题分析：这里主要的思路是，利用递归，先判断是否为空，然后在判断临时变量统计的和是否等于目标值，递归的时候，每次开始的时候都是从它本身开始，因为，它可以使用无限次，只需判断当它的和大于Target时，就停止递归

简化版本

class Solution(object):
    def __init__(self):
        self.ans = []
    def combinationSum(self, candidates, target):
        """
        :type candidates: List[int]
        :type target: int
        :rtype: List[List[int]]
        """
        if not candidates:
            return self.ans
        self.backtriking(0, candidates, target, 0, [])
        return self.ans
    def backtriking(self,start, candidates, target, sumTmp, li):
        if sumTmp == target:
            self.ans.append(li)
            return
        if sumTmp > target:
            return
        for i in range(start, len(candidates)):
            self.backtriking(i, candidates, target, sumTmp + candidates[i], li +[candidates[i]])

二、组合总和 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(object):
    def __init__(self):
        self.ans = []
    def combinationSum2(self, candidates, target):
        """
        :type candidates: List[int]
        :type target: int
        :rtype: List[List[int]]
        """
        if not candidates:
            return self.ans
        candidates.sort() # 为什么要升序呢，因为是两个相同的数相邻，如果第一个数已经求出来了，那么第二个数在求组合就没必要了，因为第一的组合已经包含后面相同数的组合了
        self.backstriking(0, candidates, target, 0, [])
        return self.ans
    def backstriking(self, start, candidates, target, sumtmp, li):
        if sumtmp == target:
            self.ans.append(li)
            return
        for i in range(start, len(candidates)):
            if i > start and candidates[i] == candidates[i - 1]:
                continue
            if sumtmp + candidates[i] > target:  # 遇到比它大的就直接调出循环，因为candidates是一个升序
                break
            self.backstriking(i + 1, candidates, target, sumtmp + candidates[i], li + [candidates[i]])

三、分割回文串

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是

回文串

。返回 s 所有可能的分割方案。

示例 1：

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

示例 2：

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

提示：

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

问题分析：这里主要是一个是回文的判定，一个数如何模拟切割线，对于回文判定，我们可以使用双指针判定，那么如何模拟切割线呢，就是通过一个变量定义为0然后，然后调用递归函数的时候给它回溯（就是变量 + 1）。递归三部曲，第一步确定参数和返回值，回溯没有返回值，所以参数是一个字符串和一个切割线的的初始位置，第二步确定中断条件，如果这个起始位置的值到了字符串的长度，那么就可以终止，第三步，循环单层逻辑，注意的是，如何取到分割的字符串呢，就要用[切割的起始位置,i]i去寻找新的切割线，然后判断它是不是回文，如果是，那么则加入，如果不是，则继续。

class Solution(object):
    def __init__(self):
        self.ans = []
        self.li = []
    def partition(self, s):
        """
        :type s: str
        :rtype: List[List[str]]
        """
        self.backtrking(0, s)
        return self.ans
    def backtrking(self,startIndex, s):
        if startIndex == len(s):  # 已经切割刀末尾了
            self.ans.append(self.li[:])

        for i in range(startIndex, len(s)):  # startindex是模拟切割线
            if self.reverse(startIndex, i, s):  # 如果是回文
                self.li.append(s[startIndex: i + 1]) # 这里的i为什么要加1呢，因为顾前不顾后
            else: # 如果不是，那么则继续
                continue
            self.backtrking(i + 1, s)
            self.li.pop()  # 回溯

    def reverse(self, start, end, s): # 判断它是不是回文字符串
        while start < end:
            if s[start] != s[end]:
                return False
            start += 1
            end -= 1
        return True