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

最新推荐文章于 2024-07-25 21:13:04 发布

请输入个昵称

最新推荐文章于 2024-07-25 21:13:04 发布

阅读量494

点赞数 13

文章标签：算法 python windows

本文链接：https://blog.csdn.net/MYSTICSHUN/article/details/140678377

版权

写代码的第二十天
回溯第二天，加油呀

39.组合总和

思路

这个题和昨天的题很相似，区别在于本题中数字可以无限制的重复使用。所以还是按照回溯的思路横向for，纵向递归。
解决问题1:参数和返回值是什么？参数需要传入的数组和target，计算总和的sums，以及for循环中每次的开始位置startindex；返回值是，设置全局变量的self.result和self.path分别存储路径和最后所有满足条件的结果，就不需要返回值进行返回了。
解决问题2:终止条件是什么？构建树，找树的叶子结点，也就是当其满足了一条路径的和等于target，那么终止。
解决问题3:单次回溯逻辑是什么？计算每次走过的路径和，然后append进path，递归下一层，然后sums减去本次的结点值，然后path pop出当前结点。
错误第一版：for循环那里报错递归深度过深，然后想到一个问题本题是只要和为target就停止，不需要再向深的地方递归了，所以加了一行判断语句。

class Solution:
    def __init__(self):
        self.result = []
        self.path = []

    def backtracing(self,candidates,sums,target,startindex):
        if sums == target:
            self.result.append(self.path.copy())
            return
        for i in range(startindex,len(candidates)):
            sums += candidates[i]
            self.path.append(candidates[i])
            self.backtracing(candidates,sums,target,i)
            sums -= candidates[i]
            self.path.pop()
    
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        self.backtracing(candidates,0,target,0)
        return self.result

正确代码：

class Solution:
    def __init__(self):
        self.result = []
        self.path = []

    def backtracing(self,candidates,sums,target,startindex):
        if sums > target:
            return
        if sums == target:
            self.result.append(self.path.copy())
            return
        for i in range(startindex,len(candidates)):
            sums += candidates[i]
            self.path.append(candidates[i])
            self.backtracing(candidates,sums,target,i)
            sums -= candidates[i]
            self.path.pop()
    
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        self.backtracing(candidates,0,target,0)
        return self.result

思路（剪枝）

当前给的candidates数组是无序的，如果把这个数组变成有序的，那么一旦当前的数加上下一层的数值大于等于target那么后面的数就不用再递归了。

class Solution:
    def __init__(self):
        self.result = []
        self.path = []

    def backtracing(self,candidates,sums,target,startindex):
        if sums > target:
            return
        if sums == target:
            self.result.append(self.path.copy())
            return
        for i in range(startindex,len(candidates)):
            sums += candidates[i]
            if sums > target:
                break
            self.path.append(candidates[i])
            self.backtracing(candidates,sums,target,i)
            sums -= candidates[i]
            self.path.pop()
    
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        candidates = sorted(candidates)
        self.backtracing(candidates,0,target,0)
        return self.result

40.组合总和II

思路

与上一题及其相似，区别在于不允许重复出现数字，但是本题中给的数组candiate中是存在重复数字的。
解决问题1:参数和返回值是什么？参数需要传入的数组和target，计算总和的sums，以及for循环中每次的开始位置startindex；返回值是，设置全局变量的self.result和self.path分别存储路径和最后所有满足条件的结果，就不需要返回值进行返回了。
解决问题2:终止条件是什么？构建树，找树的叶子结点，也就是当其满足了一条路径的和等于target，那么终止。
解决问题3:单次回溯逻辑是什么？计算每次走过的路径和，然后append进path，递归下一层，然后sums减去本次的结点值，然后path pop出当前结点。
错误第一版：根本没去重笑死。以为做了剪枝就是去重了。
分析一下如何去重，在本题中去重指的是原始的candidate数组中有重复数字，那么重复的抽取这个数字得到的结果是一样的，所以要把这部分重复的数字去掉。

class Solution:
    def __init__(self):
        self.path = []
        self.result = []

    def backtracing(self,candidates,target,sums,startindex):
        if target == sums:
            self.result.append(self.path.copy())
            return
        for i in range(startindex,len(candidates)):
            sums += candidates[i]
            if sums > target:
                break
            self.path.append(candidates[i])
            self.backtracing(candidates,target,sums,i+1)
            sums -= candidates[i]
            self.path.pop()

    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        candidates = sorted(candidates)
        self.backtracing(candidates,target,0,0)
        return self.result

错误第二版：在for循环中的while循环里面更改i是没意义的，外层的循环i是不会被改变的。

class Solution:
    def __init__(self):
        self.path = []
        self.result = []

    def backtracing(self,candidates,target,sums,startindex):
        if target == sums:
            self.result.append(self.path.copy())
            return
        for i in range(startindex,len(candidates)):
            while i > startindex and candidates[i-1] == candidates[i]:
                i += 1
            sums += candidates[i]
            if sums > target:
                break
            self.path.append(candidates[i])
            self.backtracing(candidates,target,sums,i+1)
            sums -= candidates[i]
            self.path.pop()

    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        candidates = sorted(candidates)
        self.backtracing(candidates,target,0,0)
        return self.result

正确代码：

 class Solution:
    def __init__(self):
        self.path = []
        self.result = []

    def backtracing(self,candidates,target,sums,startindex):
        if target == sums:
            self.result.append(self.path.copy())
            return
        for i in range(startindex,len(candidates)):
            if i > startindex and candidates[i-1] == candidates[i]:
                continue
            sums += candidates[i]
            if sums > target:
                break
            self.path.append(candidates[i])
            self.backtracing(candidates,target,sums,i+1)
            sums -= candidates[i]
            self.path.pop()

    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        candidates = sorted(candidates)
        self.backtracing(candidates,target,0,0)
        return self.result

131.分割回文串

思路

先画个树，如下图所示。在这个题中我们要的是分割！！！不是前几道题的组合，从数组中拿一个那种，而是按顺序的切！！！！看下面这个图以aab为例：aab第一刀可以有三种切法a｜ab，aa｜b，aab｜分别在这三个位置切，这个是第一层的切法；第二刀在第一刀的基础上切a｜a｜b或者a｜ab｜，aa｜b｜，无（我这里是和上面的第一刀的三种情况对应的）；第三刀在前两刀的基础上切，a｜a｜b｜或无，无，无（这里是和上面第二刀的几种情况对应的）；没有第四刀了，结束，然后开始判断这几个是不是回文串，要是的话加入全局变量result。
在这里插入图片描述
解决问题1:参数和返回值是什么？参数需要传入的字符串和记录每次遍历开始的字符串的位置也就是每次的切割线的位置startindex；返回值是，设置全局变量的self.result和self.path分别存储路径和最后所有满足条件的结果，就不需要返回值进行返回了。
解决问题2:终止条件是什么？构建树，找树的叶子结点，也就是当最后一刀切在了最后一个字符后面，那么终止。把是否是回文串的判断写在了单次回溯的逻辑中。
解决问题3:单次回溯逻辑是什么？for循环中递归，然后每次都要判断这个字符串是不是回文串，如果是就append进result。
错误第一版：输出值为空！！！！！！也就是path里面没内容，所以定位到append进path的那句话，path要加的是一个字符串，而不是一个单独的字符！！！并且是满足回文串格式的字符串！！！所以怎么能是s[i]呢！！！！应该是一个范围。startindex是每次切割线的位置，也就是说切割线前面的字符是已经使用过判断过的，那么接下来要做的就是startindex之后的字符串了，所以字符串的范围应该是s[startindex:XXX]但是到哪里结束呢？我们从startindex开始之后的每一个子字符串都是需要的，所以可以用for循环中的i来表示，但是初始化i=startindex，所以范围可以是到i+1。

class Solution:
    def __init__(self):
        self.path = []
        self.result = []
    def backtracing(self,s,startindex):
        if startindex == len(s)-1:
            self.result.append(self.path.copy())
            return
        for i in range(startindex,len(s)):
            if self.isPalindrome(s):
                self.path.append(s[i])
                self.backtracing(s,i+1)
                self.path.pop()
    def isPalindrome(self,s):
        s = list(s)
        if s == s[::-1]:
            return True
        return False
    def partition(self, s: str) -> List[List[str]]:
        self.backtracing(s,0)
        return self.result

错误第二版：还是空的啊啊啊啊啊啊！！！判断回文串怎们能把参数设为s呢！！！！！应该是当前的字符串啊啊啊啊啊！！！！

class Solution:
    def __init__(self):
        self.path = []
        self.result = []
    def backtracing(self,s,startindex):
        if startindex == len(s)-1:
            self.result.append(self.path.copy())
            return
        for i in range(startindex,len(s)):
            if self.isPalindrome(s):
                self.path.append(s[startindex:i+1])
                self.backtracing(s,i+1)
                self.path.pop()
    def isPalindrome(self,s):
        s = list(s)
        if s == s[::-1]:
            return True
        return False
    def partition(self, s: str) -> List[List[str]]:
        self.backtracing(s,0)
        return self.result

错误第三版：字符串中最后一个字符去哪了！！！！一定是范围问题！！！应该是startindex = = len(s) 而不是 startindex == len(s) - 1。因为range 函数不包含终止点，所以range(startindex, len(s)) 实际上不包括len(s)。

class Solution:
    def __init__(self):
        self.path = []
        self.result = []
    def backtracing(self,s,startindex):
        if startindex == len(s)-1:
            self.result.append(self.path.copy())
            return
        for i in range(startindex,len(s)):
            if self.isPalindrome(s[startindex:i+1]):
                self.path.append(s[startindex:i+1])
                self.backtracing(s,i+1)
                self.path.pop()
    def isPalindrome(self,s):
        s = list(s)
        if s == s[::-1]:
            return True
        return False
    def partition(self, s: str) -> List[List[str]]:
        self.backtracing(s,0)
        return self.result

在这里插入图片描述
正确代码：

class Solution:
    def __init__(self):
        self.path = []
        self.result = []
    def backtracing(self,s,startindex):
        if startindex == len(s):
            self.result.append(self.path.copy())
            return
        for i in range(startindex,len(s)):
            if self.isPalindrome(s[startindex:i+1]):
                self.path.append(s[startindex:i+1])
                self.backtracing(s,i+1)
                self.path.pop()
    def isPalindrome(self,s):
        s = list(s)
        if s == s[::-1]:
            return True
        return False
    def partition(self, s: str) -> List[List[str]]:
        self.backtracing(s,0)
        return self.result

请输入个昵称

关注

13
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
代码随想录算法训练营第二十天|39. 组合总和、40.组合总和II、131.分割回文串

写代码的第二十天回溯第二天，加油呀。
复制链接

扫一扫