代码随想录算法训练营第十五天 | 回溯系列1与回溯系列2

我爱py数据分析

已于 2023-07-12 13:39:57 修改

阅读量591

点赞数

文章标签：算法

于 2023-07-12 01:33:55 首次发布

本文链接：https://blog.csdn.net/weixin_45690942/article/details/131649317

版权

回溯系列1与回溯系列2

回溯算法理论基础
77 组合问题
216 组合总和 III
17 电话号码的字母组合
回溯系列1总结
39 组合总和
40 组合总和II
131 分割回文串
93 复原IP地址
78 子集
回溯系列2总结

回溯算法理论基础

因为回溯的本质是穷举，穷举所有可能，然后选出我们想要的答案，如果想让回溯法高效一些，可以加一些剪枝的操作，但也改不了回溯法就是穷举的本质。、

回溯法并不高效为什么还要用它呢？
因为没得选，一些问题能暴力搜出来就不错了，撑死了再剪枝一下，还没有更高效的解法。
在这里插入图片描述
组合是不强调元素顺序的，排列是强调元素顺序。组合无序，排列有序。

回溯法解决的问题都可以抽象为树形结构。因为回溯法解决的都是在集合中递归查找子集，集合的大小就构成了树的宽度，递归的深度，都构成的树的深度。递归就要有终止条件，所以必然是一棵高度有限的树（N叉树）。

在这里插入图片描述

可以从图中看出for循环可以理解是横向遍历，backtracking（递归）就是纵向遍历，这样就把这棵树全遍历完了，一般来说，搜索叶子节点就是找的其中一个结果了。

在这里插入图片描述

77 组合问题

未看解答写的青春版

class Solution:
    def combine(self, n: int, k: int) -> List[List[int]]:
        if k > n :
            return [[]]
        elif k==n :
            return [[x for x in range(1,n+1)]]

        else :
            self.res = []
            idx = 1
            path = []
            self.digui(n,k,path,idx)
            return self.res


    def digui(self,n,k,path,idx):
        if k == 0:
            self.res.append(path.copy())
            return 
        # 这里当i遍历到n-1就可以停止了，此时只剩(n-1,n)这一种情况
        for i in range(idx,n+1):
            path.append(i)
            k -= 1
            self.digui(n,k,path,i+1)
            path.pop()
            k += 1
        return

重点

在这里插入图片描述

本题要学的主要是：想到使用剪枝的思想。剪枝优化只优化单层搜索的逻辑。

代码随想录的代码

未剪枝优化

class Solution:
    def combine(self, n: int, k: int) -> List[List[int]]:
        result = []  # 存放结果集
        self.backtracking(n, k, 1, [], result)
        return result
    def backtracking(self, n, k, startIndex, path, result):
        if len(path) == k:
            result.append(path[:])
            return
        for i in range(startIndex, n + 1):  # 需要优化的地方
            path.append(i)  # 处理节点
            self.backtracking(n, k, i + 1, path, result)
            path.pop()  # 回溯，撤销处理的节点

剪枝优化

class Solution:
    def combine(self, n: int, k: int) -> List[List[int]]:
        result = []  # 存放结果集
        self.backtracking(n, k, 1, [], result)
        return result
    def backtracking(self, n, k, startIndex, path, result):
        if len(path) == k:
            result.append(path[:])
            return
        for i in range(startIndex, n - (k - len(path)) + 2):  # 优化的地方
            path.append(i)  # 处理节点
            self.backtracking(n, k, i + 1, path, result)
            path.pop()  # 回溯，撤销处理的节点

我的代码(当天晚上理解后自己编写)

class Solution:
    def combine(self, n: int, k: int) -> List[List[int]]:
        self.res = []
        idx = 1
        path = []
        self.backtracking(n,k,idx,path)
        return self.res


    def backtracking(self,n,k,idx,path):
        if len(path)==k:
            self.res.append(path.copy())
            return

        for i in range(idx,n-(k-len(path))+2) :
            path.append(i)
            self.backtracking(n,k,i+1,path)
            path.pop()

216 组合总和 III

未看解答写的青春版

class Solution:
    def combinationSum3(self, k: int, n: int) -> List[List[int]]:
        kmin = 0
        kmax = 0
        nums = [i for i in range(1,10)]
        for i in range(k):
            kmin += nums[i]
            kmax += nums[8-i]
        if n < kmin or n > kmax :
            return []
        

        self.res = []
        path = []
        idx = 1
        self.digui(k,n,path,idx)
        return self.res


    def digui(self,k,n,path,idx):
        # 这里要注意，使用剪枝方案，每次递归的K不能做更改，因为要用在for循环中
        # 所以这里不再是 k==0 而是 len(path)==k
        if len(path)==k :
            if n == 0 :
                self.res.append(path.copy()) 
            return
        for i in range(idx,9-(k-len(path))+2):
            if 9-idx+1 == k-len(path) :
                temp = [i for i in range(idx,10)]
                path = path + temp
                add = sum(temp)
                if add == n :
                    self.res.append(path.copy()) 
                return 

            # 自己做了一点剪枝，除了前面在循环上做文章，目前也只能想到用范围稍微控制一下
            if k-len(path) == 1 :
                if n >= idx and n <= 9 :
                    path.append(n)
                    self.res.append(path.copy())
                    path.pop()
                    return
                else :
                    return
            if k-len(path) == 2 :
                if n < idx+idx+1 or n > 9+8 :
                    return 
                
            path.append(i)          
            self.digui(k,n-i,path,i+1)
            path.pop()
        return

看了解答后修改

看了代码随想录的解答，发现和我想的剪枝策略，我忘了一个最朴素的，当 n < 0 时，return , 加上即可。

class Solution:
    def combinationSum3(self, k: int, n: int) -> List[List[int]]:
        kmin = 0
        kmax = 0
        nums = [i for i in range(1,10)]
        for i in range(k):
            kmin += nums[i]
            kmax += nums[8-i]
        if n < kmin or n > kmax :
            return []
        

        self.res = []
        path = []
        idx = 1
        self.digui(k,n,path,idx)
        return self.res


    def digui(self,k,n,path,idx):
        # 这里要注意，使用剪枝方案，每次递归的K不能做更改，因为要用在for循环中
        # 所以这里不再是 k==0 而是 len(path)==k
        if len(path)==k :
            if n == 0 :
                self.res.append(path.copy()) 
            return
        if n < 0 :
            return 
        for i in range(idx,9-(k-len(path))+2):
            if 9-idx+1 == k-len(path) :
                temp = [i for i in range(idx,10)]
                path = path + temp
                add = sum(temp)
                if add == n :
                    self.res.append(path.copy()) 
                return 

            # 自己做了一点剪枝，除了前面在循环上做文章，目前也只能想到用范围稍微控制一下
            if k-len(path) == 1 :
                if n >= idx and n <= 9 :
                    path.append(n)
                    self.res.append(path.copy())
                    path.pop()
                    return
                else :
                    return
            if k-len(path) == 2 :
                if n < idx+idx+1 or n > 9+8 :
                    return 
                
            path.append(i)          
            self.digui(k,n-i,path,i+1)
            path.pop()
        return

重点

代码随想录的代码

class Solution:
    def combinationSum3(self, k: int, n: int) -> List[List[int]]:
        result = []  # 存放结果集
        self.backtracking(n, k, 0, 1, [], result)
        return result

    def backtracking(self, targetSum, k, currentSum, startIndex, path, result):
        if currentSum > targetSum:  # 剪枝操作
            return  # 如果path的长度等于k但currentSum不等于targetSum，则直接返回
        if len(path) == k:
            if currentSum == targetSum:
                result.append(path[:])
            return
        for i in range(startIndex, 9 - (k - len(path)) + 2):  # 剪枝
            currentSum += i  # 处理
            path.append(i)  # 处理
            self.backtracking(targetSum, k, currentSum, i + 1, path, result)  # 注意i+1调整startIndex
            currentSum -= i  # 回溯
            path.pop()  # 回溯

我的代码(当天晚上理解后自己编写)

class Solution:
    def combinationSum3(self, k: int, n: int) -> List[List[int]]:
       self.res = []
       path = []
       idx = 1

       self.backtracking(k,n,idx,path)
       return self.res

    def backtracking(self,k,n,idx,path):
        if len(path)==k:
            if n == 0 :
                self.res.append(path.copy())
            return
        if n < 0 :
            return

        for i in range(idx,9-(k-len(path))+2):
            path.append(i)
            self.backtracking(k,n-i,i+1,path)
            path.pop()

        return

17 电话号码的字母组合

未看解答写的青春版

这道题在第一次写的时候，认为不需要剪枝的操作。

class Solution:
    def letterCombinations(self, digits: str) -> List[str]:
        if digits == "" :
            return []

        mmap = {2:'abc',3:'def',4:'ghi',5:'jkl',6:'mno',7:'pqrs',8:'tuv',9:'wxyz'}
        for i in range(len(mmap)):
            mmap[2+i] = [i for i in mmap[2+i]]

        if len(digits) == 1 :
            return mmap[int(digits)]
            
        self.res = []
        n = len(digits)
        path = []

        self.digui(mmap,n,digits,0,path)
        return self.res

    def digui(self,mmap,n,digits,numidx,path):
        if len(path) == n :
            self.res.append(''.join(path))
            return
        
        for i in range(numidx,n):
            strlist = mmap[int(digits[i])]
            number = len(strlist)
            for j in range(number) :
                path.append(strlist[j])
                self.digui(mmap,n,digits,i+1,path)
                path.pop()
        return

重点

1、由于题目中说明了不需要考虑异常的情况，我也就没有考虑，但是在面试中一定要注意异常的处理，处理方法是在map的设置中，将非法的0和1设置为空字符。

2、代码随想录的代码中只用了一层for循环？好好看看
原因：在我之前写的代码中，第一层循环 i 和我设置的 numidx 重复了。所以第一层循环可去掉。

class Solution:
    def letterCombinations(self, digits: str) -> List[str]:
        if digits == "" :
            return []

        mmap = {2:'abc',3:'def',4:'ghi',5:'jkl',6:'mno',7:'pqrs',8:'tuv',9:'wxyz'}
        for i in range(len(mmap)):
            mmap[2+i] = [i for i in mmap[2+i]]

        if len(digits) == 1 :
            return mmap[int(digits)]
            
        self.res = []
        n = len(digits)
        path = []

        self.digui(mmap,n,digits,0,path)
        return self.res

    def digui(self,mmap,n,digits,numidx,path):
        if len(path) == n :
            self.res.append(''.join(path))
            return
        
        
        strlist = mmap[int(digits[numidx])]
        number = len(strlist)
        for j in range(number) :
            path.append(strlist[j])
            self.digui(mmap,n,digits,numidx+1,path)
            path.pop()
        return

代码随想录的代码

回溯

class Solution:
    def __init__(self):
        self.letterMap = [
            "",     # 0
            "",     # 1
            "abc",  # 2
            "def",  # 3
            "ghi",  # 4
            "jkl",  # 5
            "mno",  # 6
            "pqrs", # 7
            "tuv",  # 8
            "wxyz"  # 9
        ]
        self.result = []
        self.s = ""
    
    def backtracking(self, digits, index):
        if index == len(digits):
            self.result.append(self.s)
            return
        digit = int(digits[index])    # 将索引处的数字转换为整数
        letters = self.letterMap[digit]    # 获取对应的字符集
        for i in range(len(letters)):
            self.s += letters[i]    # 处理字符
            self.backtracking(digits, index + 1)    # 递归调用，注意索引加1，处理下一个数字
            self.s = self.s[:-1]    # 回溯，删除最后添加的字符
    
    def letterCombinations(self, digits):
        if len(digits) == 0:
            return self.result
        self.backtracking(digits, 0)
        return self.result

回溯优化使用列表

class Solution:
    def __init__(self):
        self.letterMap = [
            "",     # 0
            "",     # 1
            "abc",  # 2
            "def",  # 3
            "ghi",  # 4
            "jkl",  # 5
            "mno",  # 6
            "pqrs", # 7
            "tuv",  # 8
            "wxyz"  # 9
        ]
    
    def getCombinations(self, digits, index, path, result):
        if index == len(digits):
            result.append(''.join(path))
            return
        digit = int(digits[index])
        letters = self.letterMap[digit]
        for letter in letters:
            path.append(letter)
            self.getCombinations(digits, index + 1, path, result)
            path.pop()
    
    def letterCombinations(self, digits):
        result = []
        if len(digits) == 0:
            return result
        self.getCombinations(digits, 0, [], result)
        return result

代码随想录还给出了另外2个回溯+精简的版本，这里先不贴出来了，二刷时可以去读读。

我的代码(当天晚上理解后自己编写)

lass Solution:

    def __init__(self):
        self.lettermap = [
            "",
            "",
            "abc",
            "def",
            "ghi",
            "jkl",
            "mno",
            "pqrs",
            "tuv",
            "wxyz"
        ]
    def letterCombinations(self, digits: str) -> List[str]:
        self.res = []
        path = []
        idx = 0
        if len(digits)==0:
            return []

        self.backtracking(digits,idx,path)

        return self.res

    def backtracking(self,digits,idx,path):
        # 这里的 if 也可以写成 if idx == len(digits) :
        if len(path) == len(digits):
            self.res.append(''.join(path))
            return

        digit = int(digits[idx])
        letters = self.lettermap[digit]
        for letter in letters :
            path.append(letter)
            self.backtracking(digits,idx+1,path)
            path.pop()

        return

回溯系列1总结

39 组合总和

未看解答写的失败版

没弄懂如何去重。

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        if candidates == []:
            return []

        if target < min(candidates) :
            return []

        self.res = []
        self.idx = 0
        path = []
        self.digui(candidates,target,path)

        return self.res

    def digui(self,candidates,target,path):
        if target == 0 :           
            self.res.append(path.copy())
            if path[-1] == candidates[-1]:
                self.idx += 1
            return 

        if target < 0 :
            return
        n = len(candidates)
        for i in range(self.idx,n) :
            number = candidates[i]
            path.append(number)
            self.digui(candidates,target-number,path)
            path.pop()
        return

看了解答写的修正版

就是简简单单的引入一个idx啊，怎么这都不会了。

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        if candidates == []:
            return []

        if target < min(candidates) :
            return []

        self.res = []
       
        path = []
        self.digui(candidates,target,path,0)

        return self.res

    def digui(self,candidates,target,path,idx):
        if target == 0 :           
            self.res.append(path.copy())
           
            return 

        if target < 0 :
            return
        n = len(candidates)
        for i in range(idx,n) :
            number = candidates[i]
            path.append(number)
            self.digui(candidates,target-number,path,i)
            path.pop()
        return

看了解答写的修正+剪枝版

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        if candidates == []:
            return []

        if target < min(candidates) :
            return []

        candidates = sorted(candidates)
        self.res = []
       
        path = []
        self.digui(candidates,target,path,0)

        return self.res

    def digui(self,candidates,target,path,idx):
        if target == 0 :           
            self.res.append(path.copy())
           
            return 

        if target < 0 :
            return
        n = len(candidates)
        for i in range(idx,n) :
            number = candidates[i]
            if target - number < 0 :
                return
            path.append(number)
            self.digui(candidates,target-number,path,i)
            path.pop()
        return

重点

本题说明，可以重复选取元素，要注意该题与上面两题的差异！

重复选取元素的题目，要先考虑两个点，是否存在0元和去重问题。如果存在0，就会出现无限循环。本题不涉及去重问题，后续题目会涉及。

也许画一画树形图，这题我就不会做错了。

代码随想录的代码

回溯（版本一）

class Solution:

    def backtracking(self, candidates, target, total, startIndex, path, result):
        if total > target:
            return
        if total == target:
            result.append(path[:])
            return

        for i in range(startIndex, len(candidates)):
            total += candidates[i]
            path.append(candidates[i])
            self.backtracking(candidates, target, total, i, path, result)  # 不用i+1了，表示可以重复读取当前的数
            total -= candidates[i]
            path.pop()

    def combinationSum(self, candidates, target):
        result = []
        self.backtracking(candidates, target, 0, 0, [], result)
        return result

回溯剪枝（版本一）

class Solution:

    def backtracking(self, candidates, target, total, startIndex, path, result):
        if total == target:
            result.append(path[:])
            return

        for i in range(startIndex, len(candidates)):
            if total + candidates[i] > target:
                break
            total += candidates[i]
            path.append(candidates[i])
            self.backtracking(candidates, target, total, i, path, result)
            total -= candidates[i]
            path.pop()

    def combinationSum(self, candidates, target):
        result = []
        candidates.sort()  # 需要排序
        self.backtracking(candidates, target, 0, 0, [], result)
        return result

回溯（版本二）

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        result =[]
        self.backtracking(candidates, target, 0, [], result)
        return result
    def backtracking(self, candidates, target, startIndex, path, result):
        if target == 0:
            result.append(path[:])
            return
        if target < 0:
            return
        for i in range(startIndex, len(candidates)):
            path.append(candidates[i])
            self.backtracking(candidates, target - candidates[i], i, path, result)
            path.pop()

回溯剪枝（版本二）

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        result =[]
        candidates.sort()
        self.backtracking(candidates, target, 0, [], result)
        return result
    def backtracking(self, candidates, target, startIndex, path, result):
        if target == 0:
            result.append(path[:])
            return

        for i in range(startIndex, len(candidates)):
            if target - candidates[i]  < 0:
                break
            path.append(candidates[i])
            self.backtracking(candidates, target - candidates[i], i, path, result)
            path.pop()

我的代码(当天晚上理解后自己编写)

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
       self.res = []
       candidates.sort()
       path = []
       idx = 0
       self.backtracking(candidates,target,idx,path)
       return self.res

    def backtracking(self,candidates,target,idx,path):
        if target == 0 :
            self.res.append(path.copy())
            return
        if target < 0 :
            return

        for i in range(idx,len(candidates)):
            if target - candidates[i] < 0 :
                return
            path.append(candidates[i])
            self.backtracking(candidates,target-candidates[i],i,path)
            path.pop()

        return

40 组合总和II

未看解答写的青春版

不会写，死在了去重逻辑上。

重点

要在递归过程中就进行去重，如果是先收集所有可能，再利用map set这种数据结构进行去重，是会超时的。

两个维度，树层去重，树枝去重。

排序的目的是让相同的元素挨在一起。

关键在于树层去重，本题树枝中的重复是合法的。

这里的去重太强了，后面回溯问题的去重逻辑，基本上都是这么写

在这里插入图片描述

代码随想录的代码

回溯

class Solution:


    def backtracking(self, candidates, target, total, startIndex, path, result):
        if total == target:
            result.append(path[:])
            return

        for i in range(startIndex, len(candidates)):
            if i > startIndex and candidates[i] == candidates[i - 1]:
                continue

            if total + candidates[i] > target:
                break

            total += candidates[i]
            path.append(candidates[i])
            self.backtracking(candidates, target, total, i + 1, path, result)
            total -= candidates[i]
            path.pop()

    def combinationSum2(self, candidates, target):
        result = []
        candidates.sort()
        self.backtracking(candidates, target, 0, 0, [], result)
        return result

回溯使用used

class Solution:


    def backtracking(self, candidates, target, total, startIndex, used, path, result):
        if total == target:
            result.append(path[:])
            return

        for i in range(startIndex, len(candidates)):
            # 对于相同的数字，只选择第一个未被使用的数字，跳过其他相同数字
            if i > startIndex and candidates[i] == candidates[i - 1] and not used[i - 1]:
                continue

            if total + candidates[i] > target:
                break

            total += candidates[i]
            path.append(candidates[i])
            used[i] = True
            self.backtracking(candidates, target, total, i + 1, used, path, result)
            used[i] = False
            total -= candidates[i]
            path.pop()

    def combinationSum2(self, candidates, target):
        used = [False] * len(candidates)
        result = []
        candidates.sort()
        self.backtracking(candidates, target, 0, 0, used, [], result)
        return result

另一种去重方式

class Solution:
    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        candidates.sort()
        results = []
        self.combinationSumHelper(candidates, target, 0, [], results)
        return results

    def combinationSumHelper(self, candidates, target, index, path, results):
        if target == 0:
            results.append(path[:])
            return
        for i in range(index, len(candidates)):
            if i > index and candidates[i] == candidates[i - 1]:
                continue  
            if candidates[i] > target:
                break  
            path.append(candidates[i])
            self.combinationSumHelper(candidates, target - candidates[i], i + 1, path, results)
            path.pop()

我的代码(当天晚上理解后自己编写)

class Solution:
    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        used = [False]*len(candidates)
        self.res = []
        candidates.sort()
        idx = 0
        path = []
        self.backtracking(candidates,target,used,idx,path)

        return self.res

    def backtracking(self,candidates,target,used,idx,path):
        if target == 0 :
            self.res.append(path.copy())
            return
        if target < 0 :
            return

        for i in range(idx,len(candidates)):
            # 注意这里的逻辑，尤其是 used 的数组的使用
            # used 为 False时，才代表着上一个为用过，如果为True，代表目前还未回溯
            # 如果为False，则代表上一个值已经回溯过，当前点为重复点
            if i > idx and candidates[i]==candidates[i-1] and not used[i-1] :
                continue

            if target - candidates[i] < 0 :
                return

            path.append(candidates[i])
            used[i]=True
            self.backtracking(candidates,target-candidates[i],used,i+1,path)
            used[i]=False
            path.pop()

        return

等一下等一下，去重这里，代码随想录的代码有一点点问题

注意，上面编写的代码都是对的，但是存在一点冲突，正确的两种去重判断如下：

if i > 0 and nums[i]==nums[i-1] and not used[i-1]:

if i > idx and nums[i]==nums[i-1]

这样理解起来，第二种不使用used数组的情况就很好理解了，所以现在我倾向于不使用used数组。

但是卡哥后面又说，used数组写法更为通用，但遇到排列问题，需要去重时，就只能使用used数组方法了。

131 分割回文串

不会写，不知道如何将切割问题转化为回溯，以及终止条件的编写

重点

单层搜索逻辑中，难点在于想到，如何表示当前要处理的子串。

代码随想录的代码

回溯基本版

class Solution:

    def partition(self, s: str) -> List[List[str]]:
        '''
        递归用于纵向遍历
        for循环用于横向遍历
        当切割线迭代至字符串末尾，说明找到一种方法
        类似组合问题，为了不重复切割同一位置，需要start_index来做标记下一轮递归的起始位置(切割线)
        '''
        result = []
        self.backtracking(s, 0, [], result)
        return result

    def backtracking(self, s, start_index, path, result ):
        # Base Case
        if start_index == len(s):
            result.append(path[:])
            return
        
        # 单层递归逻辑
        for i in range(start_index, len(s)):
            # 此次比其他组合题目多了一步判断：
            # 判断被截取的这一段子串([start_index, i])是否为回文串
            if self.is_palindrome(s, start_index, i):
                path.append(s[start_index:i+1])
                self.backtracking(s, i+1, path, result)   # 递归纵向遍历：从下一处进行切割，判断其余是否仍为回文串
                path.pop()             # 回溯


    def is_palindrome(self, s: str, start: int, end: int) -> bool:
        i: int = start        
        j: int = end
        while i < j:
            if s[i] != s[j]:
                return False
            i += 1
            j -= 1
        return True

回溯+优化判定回文函数

class Solution:

    def partition(self, s: str) -> List[List[str]]:
        result = []
        self.backtracking(s, 0, [], result)
        return result

    def backtracking(self, s, start_index, path, result ):
        # Base Case
        if start_index == len(s):
            result.append(path[:])
            return
        
        # 单层递归逻辑
        for i in range(start_index, len(s)):
            # 若反序和正序相同，意味着这是回文串
            if s[start_index: i + 1] == s[start_index: i + 1][::-1]:
                path.append(s[start_index:i+1])
                self.backtracking(s, i+1, path, result)   # 递归纵向遍历：从下一处进行切割，判断其余是否仍为回文串
                path.pop()             # 回溯

回溯+高效判断回文子串

class Solution:
    def partition(self, s: str) -> List[List[str]]:
        result = []
        isPalindrome = [[False] * len(s) for _ in range(len(s))]  # 初始化isPalindrome矩阵
        self.computePalindrome(s, isPalindrome)
        self.backtracking(s, 0, [], result, isPalindrome)
        return result

    def backtracking(self, s, startIndex, path, result, isPalindrome):
        if startIndex >= len(s):
            result.append(path[:])
            return

        for i in range(startIndex, len(s)):
            if isPalindrome[startIndex][i]:   # 是回文子串
                substring = s[startIndex:i + 1]
                path.append(substring)
                self.backtracking(s, i + 1, path, result, isPalindrome)  # 寻找i+1为起始位置的子串
                path.pop()           # 回溯过程，弹出本次已经填在的子串

    def computePalindrome(self, s, isPalindrome):
        for i in range(len(s) - 1, -1, -1):  # 需要倒序计算，保证在i行时，i+1行已经计算好了
            for j in range(i, len(s)):
                if j == i:
                    isPalindrome[i][j] = True
                elif j - i == 1:
                    isPalindrome[i][j] = (s[i] == s[j])
                else:
                    isPalindrome[i][j] = (s[i] == s[j] and isPalindrome[i+1][j-1])

回溯+使用all函数判断回文子串

class Solution:
    def partition(self, s: str) -> List[List[str]]:
        result = []
        self.partition_helper(s, 0, [], result)
        return result

    def partition_helper(self, s, start_index, path, result):
        if start_index == len(s):
            result.append(path[:])
            return

        for i in range(start_index + 1, len(s) + 1):
            sub = s[start_index:i]
            if self.isPalindrome(sub):
                path.append(sub)
                self.partition_helper(s, i, path, result)
                path.pop()

    def isPalindrome(self, s):
        return all(s[i] == s[len(s) - 1 - i] for i in range(len(s) // 2))

我的代码(当天晚上理解后自己编写)

class Solution:
    def partition(self, s: str) -> List[List[str]]:
        self.res = []
        path = []
        idx = 0
        self.backtracking(s,idx,path)

        return self.res

    def backtracking(self,s,idx,path):
        if idx == len(s):
            self.res.append(path.copy())
            return

        for i in range(idx,len(s)):
            if self.is_palindrome(s,idx,i):
                path.append(s[idx:i+1])
                self.backtracking(s,i+1,path)
                path.pop()

        return
        
    def is_palindrome(self,s,start,end):
        i = start
        j = end
        while i < j :
            if s[i]!=s[j]:
                return False

            i += 1
            j -= 1
        return True

93 复原IP地址

依照上一题切割代码改的稚嫩版

class Solution:
    def restoreIpAddresses(self, s: str) -> List[str]:
        result = []
        self.backtracking(s, 0, [], result,0)
        return result

    def backtracking(self, s, start_index, path, result,count):
        
        # 这里的判断条件要注意细节，注意是双重判断，满足4就要return
        # 满足切割条件，才可以收获结果
        if count == 4 :
            if start_index == len(s):
                result.append('.'.join(path))
            return
        
        # 单层递归逻辑
        for i in range(start_index, len(s)):

            # 这里自己加的一个小剪枝，注意 len(s)-start_index是否要加1的细节
            if count == 3 and len(s)-start_index >= 4 :
                return 
             
            if self.is_right(s, start_index, i):
                path.append(s[start_index:i+1])
                self.backtracking(s, i+1, path, result,count+1)  
                path.pop()             # 回溯

        return 

    def is_right(self,s,start,end):
        string = s[start:end+1]
        n = len(string)
        if n > 1 :
            if int(string[0]) == 0 :
                return False
        number = int(string)
        if number >= 0 and number <= 255 :
            return True
        else:
            return False

重点

这道题的重点还是，在切割的题中，如何确定当前切割的字符串。

同时，如何返回值也是本题的重点，不能单单 count ==4 ，还要有一个切割的判断条件。

代码随想录的剪枝策略比我自己写的高明一些，我只判断了当count=3时，剩下是否是三位数，但是代码随想录则是，当count=3时，剩下的直接当做第四串。

代码随想录的代码

回溯（版本一）

class Solution:
    def restoreIpAddresses(self, s: str) -> List[str]:
        result = []
        self.backtracking(s, 0, 0, "", result)
        return result

    def backtracking(self, s, start_index, point_num, current, result):
        if point_num == 3:  # 逗点数量为3时，分隔结束
            if self.is_valid(s, start_index, len(s) - 1):  # 判断第四段子字符串是否合法
                current += s[start_index:]  # 添加最后一段子字符串
                result.append(current)
            return

        for i in range(start_index, len(s)):
            if self.is_valid(s, start_index, i):  # 判断 [start_index, i] 这个区间的子串是否合法
                sub = s[start_index:i + 1]
                self.backtracking(s, i + 1, point_num + 1, current + sub + '.', result)
            else:
                break

    def is_valid(self, s, start, end):
        if start > end:
            return False
        if s[start] == '0' and start != end:  # 0开头的数字不合法
            return False
        num = 0
        for i in range(start, end + 1):
            if not s[i].isdigit():  # 遇到非数字字符不合法
                return False
            num = num * 10 + int(s[i])
            if num > 255:  # 如果大于255了不合法
                return False
        return True

回溯（版本二）

class Solution:
    def restoreIpAddresses(self, s: str) -> List[str]:
        results = []
        self.backtracking(s, 0, [], results)
        return results

    def backtracking(self, s, index, path, results):
        if index == len(s) and len(path) == 4:
            results.append('.'.join(path))
            return

        if len(path) > 4:  # 剪枝
            return

        for i in range(index, min(index + 3, len(s))):
            if self.is_valid(s, index, i):
                sub = s[index:i+1]
                path.append(sub)
                self.backtracking(s, i+1, path, results)
                path.pop()

    def is_valid(self, s, start, end):
        if start > end:
            return False
        if s[start] == '0' and start != end:  # 0开头的数字不合法
            return False
        num = int(s[start:end+1])
        return 0 <= num <= 255

我的代码(当天晚上理解后自己编写)

class Solution:
    def restoreIpAddresses(self, s: str) -> List[str]:
       self.res = []
       idx = 0
       path = []
       

       self.backtracking(s,idx,path)

       return self.res

    def backtracking(self,s,idx,path):
        if len(path) == 4 and idx == len(s):
            self.res.append('.'.join(path))
            return

        # 这个剪枝很精妙啊。由于最大长度只能为3个的限制，这里i最大也只能往后取三个数
        for i in range(idx,min(idx+3,len(s))):
            if self.is_valid(s,idx,i):
                sub = s[idx:i+1]
                path.append(sub)
                self.backtracking(s,i+1,path)
                path.pop()

        return

    def is_valid(self,s,start,end):
        if start > end :
            return False

        if s[start]=='0' and start != end :
            return False
        num = int(s[start:end+1])
        return 0 <= num <= 255

78 子集

未看解答写的青春版

没想到如何剪枝，后面看解答看看是否有剪枝操作。

class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:

        if nums == [] :
            return []

        self.res = []
        path = []
        idx = 0
        self.digui(nums,path,idx)
        self.res.append([])
        return self.res

    def digui(self,nums,path,idx):

        n = len(nums)
        for i in range(idx,n):
            path.append(nums[i])
            self.res.append(path.copy())
            self.digui(nums,path,i+1)
            path.pop()

重点

本题的主要差别在于收获结果的过程。

在每一层递归进行收获结果。

代码随想录的代码

class Solution:
    def subsets(self, nums):
        result = []
        path = []
        self.backtracking(nums, 0, path, result)
        return result

    def backtracking(self, nums, startIndex, path, result):
        result.append(path[:])  # 收集子集，要放在终止添加的上面，否则会漏掉自己
        # if startIndex >= len(nums):  # 终止条件可以不加
        #     return
        for i in range(startIndex, len(nums)):
            path.append(nums[i])
            self.backtracking(nums, i + 1, path, result)
            path.pop()

我的代码(当天晚上理解后自己编写)

class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:

        if nums == [] :
            return []

        self.res = []
        path = []
        idx = 0
        self.digui(nums,path,idx)
        self.res.append([])
        return self.res

    def digui(self,nums,path,idx):

        n = len(nums)
        for i in range(idx,n):
            path.append(nums[i])
            self.res.append(path.copy())
            self.digui(nums,path,i+1)
            path.pop()