【LeetCode】回溯算法类题目详解

news2024/11/16 23:25:11

所有题目均来自于LeetCode，刷题代码使用的Python3版本

image-20240305152953604

回溯算法

回溯算法是一种搜索的方法，在二叉树总结当中，经常使用到递归去解决相关的问题，在二叉树的所有路径问题中，我们就使用到了回溯算法来找到所有的路径。

回溯算法本质就是去穷举，性能并不是那么高效。一般为了提高效率，往往回溯算法会跟剪枝操作相结合。

回溯算法通常可以用来解决一些问题，这也是为什么会有回溯算法的原因

  • 组合问题
    • N个数里面按照一定规则找出k个数的集合。组合不强调元素的顺序
  • 切割问题
    • 一个字符串按一定规则有几种切割方式
      • 分割回文串
      • 复原IP地址
  • 子集问题
    • 一个N个数的集合里有多少符合条件的子集
  • 排列问题
    • N个数按照一定规则全排列，有几种排列方式。排列强调元素的顺序
  • 棋盘问题
    • N皇后、解数独问题

理解回溯

回溯法解决的问题都可以抽象为树形结构，回溯算法解决问题都是在集合中递归查找子集，集合的大小构成了树的宽度，递归的深度构成了树的深度。

递归必须要有终止条件，所以一定是一个高度有限的N叉树。

回溯模板

递归三部曲：

  • 返回值及参数
    • void backtracking(参数)
  • 回溯函数的终止条件
  • 回溯搜索的遍历过程
    • 回溯算法理论基础
void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

    for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
        处理节点;
        backtracking(路径，选择列表); // 递归
        回溯，撤销处理结果
    }
}

练习题

77、组合

image-20231122103657483

class Solution:
    def combine(self, n: int, k: int) -> List[List[int]]:
        def backtracking(n,k,startindex,path):
            if len(path)==k:
                # 这里需要注意，因为列表在Python中是可变数据类型，后面的修改会导致path变为[]
                res.append(path[:])
                return 
            # 这里的startindex代表的是在单层递归中需要遍历的次数 从startindex一直到n寻找符合条件的数
            for i in range(startindex, n+1):
                path.append(i)
                backtracking(n,k,i+1,path)
                a = path.pop()
        
        res = []
        backtracking(n,k,1,[])
        return res

image-20231122104026446

回溯+剪枝

使用剪枝的原理就在于如果剩余的元素个数已经小于k-len(path)的时候，我们就不再往下继续了。

  1. 已经选择过的元素个数：len(path)
  2. 还需要选择的个数：k-len(path)
  3. 在集合中更需要从最多要从下标为n-(k-len(path))+1开始遍历，在python中因为range循环的时候是左闭右开，所以还需要+1

77.组合4

class Solution:
    def combine(self, n: int, k: int) -> List[List[int]]:
        def backtracking(n,k,startindex,path):
            if len(path)==k:
                # print(path)
                # 这里需要注意，因为列表在Python中是可变数据类型，后面的修改会导致path变为[]
                res.append(path[:])
                return 
           	
            for i in range(startindex, n-(k-len(path))+1+1):
                path.append(i)
                backtracking(n,k,i+1,path)
                # 回溯 退出上一个元素
                path.pop()
        
        res = []
        backtracking(n,k,1,[])
        return res

image-20231125142534496

2024更新代码：【传递的参数不要过多，题目已经给出的参数就不需要再进行传递了】

class Solution:
    def combine(self, n: int, k: int) -> List[List[int]]:
        res = []

        def backtracking(startIndex, path):
            if len(path) == k:
                res.append(path[:])
                return
            for i in range(startIndex, n - (k - len(path)) + 1 + 1):
                path.append(i)
                backtracking(i + 1, path)
                path.pop()

        backtracking(1, [])
        return res

image-20240313130428518

216、组合总数III

image-20231122174951944

利用回溯代码模板。其中需要注意的是，如果path列表的和已经超过n，那么可以直接进行剪枝，除此之外，如果剩余的数字长度小于k-len(path)的话，就可以不用继续循环了，这一点也方便我们进行剪枝。

递归的三要素

  • 返回值和参数
def backtracking(n,k,startindex,path):
    pass
  • 递归终止条件
if sum(path)>n:
    return 
if len(path)==k and sum(path)==n:
    res.append(path[:])
    return
  • 递归体部分
for i in range(startindex,9 - (k - len(path)) + 1 + 1):
    path.append(i)
    backtracking(n,k,i+1,path)
    path.pop()

代码

class Solution:
    def combinationSum3(self, k: int, n: int) -> List[List[int]]:
        def backtracking(n,k,startindex,path):
            # 剪枝
            if sum(path)>n:
                return 
            if len(path)==k and sum(path)==n:
                res.append(path[:])
                return
            for i in range(startindex,9 - (k - len(path))+1+1):
                path.append(i)
                backtracking(n,k,i+1,path)
                path.pop()
        
        res = []
        backtracking(n,k,1,[])
        return res

17、电话号码的字母组合

image-20231122151406020

image-20231122151443212

思路

本题类似于组合问题，需要根据输入的数字对其能够涵盖的字母进行组合，需要解决下面几个问题：

  • 数字和字母如何进行映射
    • 采用一个列表，位置0和位置1的地方空出来，从2开始对应号码上的字母，用字符串表示
  • 两个字母两个for循环，三个字母三个for循环，多个字母多个for循环
  • 输入异常字母如何进行处理？
    • 对于空的digits需要返回一个空列表

递归三要素

  • 递归的参数

参数是digits和index，其中digits是题目给出的字符串，如“23”，而index是记录当前已经遍历到第几个数字了。【实际可以不用digits】

  • 递归结束的条件

如果index的长度和digits长度一样的话，直接return

if index==len(digits):
    res.append(path) # 这里的path被定义为字符串 而字符串在python中是不可变数据类型，因此可以直接用
    return
  • 递归体部分

需要注意的是，回溯的时候对于字符串要想去掉最后一个字符的方法是直接s=s[:-1]。

# 获取字符串中的数字
mynum = int(digits[index])
# 获取电话号码对应的字符组合
char = myhash[mynum]
for i in range(len(char)):
    path+=char[i]
    backtracking(digits, index+1, path)
    path = path[:-1] # 刨去字符串的最后一个字符

本题是不需要startindex的，因为遍历的不是同一个集合，而是不同的集合。在回溯问题中，如果是遍历同一个集合就需要传递一个参数startindex，用来表示的当前遍历到集合中的第几位。

本题通过index来判断目前遍历到第几个数字，并且index是通过充当函数的参数来实现的。

class Solution:
    def letterCombinations(self, digits: str) -> List[str]:
        myhash = ["","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"]
        res = []
        s = ""
        def backtracking(digits, index):
            nonlocal s
            if index==len(digits):
                res.append(s)
                return 
            # digit表示digits中的数字
            digit = int(digits[index])
            # letters表示digit所代表的数字对应的字母有哪些
            letters = myhash[digit]
            # for循环遍历这些字母 
            for i in range(len(letters)):
                s+=letters[i]
                # 进行回溯
                backtracking(digits,index+1)
                s = s[:-1]
        if len(digits)==0:
            return res
        backtracking(digits,0)
        return res

本题有一个需要特殊处理的地方，如果digits为空字符串的话，直接返回空列表，不需要在进行递归回溯了。

image-20231122151431566

class Solution:
    def letterCombinations(self, digits: str) -> List[str]:
        if len(digits)==0:
            return []
        numList = ["", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"]
        res = []
        s = ""
        def backtracking(index):
            nonlocal s
            if len(digits) == len(s):
                res.append(s)
                return
            digit = int(digits[index])
            chars = numList[digit]
            for i in range(len(chars)):
                s+=chars[i]
                backtracking(index+1)
                s = s[:-1]
        backtracking(0)
        return res

39、组合总数

image-20231122222712060

image-20231122222723187

本题中说了candidates中的同一个数字可以无限制重复被选取，所以我们在进行递归的时候，传递的startindex就是i。

这里需要注意的是：每次需要传入startIndex的原因是可以避免选取之前已经取过的数字

39.组合总和

本题中需要注意及时剪枝（即当sum_>target之后就可以不用往下进行回溯了），并且可以使用一个累加的sum_代替掉使用内置的sum方法，节省时间开销。

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        res = []
        sum_ = 0

        def backtracking(startIndex, path):
            nonlocal sum_
            if sum_ > target:
                return
            if sum_ == target:
                res.append(path[:])
                return
            for i in range(startIndex, len(candidates)):
                path.append(candidates[i])
                sum_ += candidates[i]
                backtracking(i, path)
                sum_ -= path.pop()

        backtracking(0, [])
        return res

image-20231122222739974

40、组合总数II（*）

image-20231123110032934

本题需要注意的是，跟前面不同的地方在于每个数字在每个组合中只能使用一次，同时在解集中不能包含重复的组合。因此想到设置一个used数组来表示每个元素是否已经被访问过。 此处也可以不使用used数组

其中candidates数组需要进行排序，这样能够保证如果数字相同的情况下，只会使用一次。

40.组合总和II

要去重的是同一层上是否使用过，可以看出在candidates[i] == candidates[i - 1]相同的情况下：

  • used[i - 1] == true，说明同一树枝candidates[i - 1]使用过
  • used[i - 1] == false，说明同一树层candidates[i - 1]使用过

40.组合总和II1

img

class Solution:
    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        res = []  # 用于记录返回结果
        sum_ = 0
        def backtracking(candidates,target,path,startindex,used):
            nonlocal sum_
            if sum_>target:
                return 
            if sum_==target:
                res.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
                path.append(candidates[i])
                sum_+=candidates[i]
                used[i]=True
                backtracking(candidates,target,path,i+1,used)
                sum_-=candidates[i]
                used[i]=False
                path.pop()
        # candidates需要进行排序，否则相同的数字可能不会连续
        candidates.sort()
        backtracking(candidates,target,[],0,[False]*len(candidates))
        return res

image-20231123110223652

优化 + 不使用used数组

class Solution:
    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        res = []

        def backtracking(candidates,target,startindex,sum_,path):
            if sum_==target:
                res.append(path[:])
                return
            for i in range(startindex, len(candidates)):
                if i>startindex and candidates[i]==candidates[i-1]:
                    continue
                sum_+=candidates[i]
                # 这里进行判断，如果超过target则直接break 免去了后面的循环 节省时间开销	
                if sum_ > target:
                    break
                path.append(candidates[i])
                backtracking(candidates,target,i+1,sum_,path)
                sum_-=candidates[i]
                path.pop()
        candidates.sort()
        backtracking(candidates,target,0,0,[])
        return res

image-20231127100152702

class Solution:
    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        res = []
        sum_ = 0

        def backtracking(startIndex, path):
            nonlocal sum_
            if sum_ > target:
                return
            if sum_ == target:
                res.append(path[:])
                return
            for i in range(startIndex, len(candidates)):
                if i > startIndex and candidates[i] == candidates[i - 1]:
                    continue
                path.append(candidates[i])
                sum_ += candidates[i]
                backtracking(i + 1, path)
                sum_ -= path.pop()

        candidates.sort()
        backtracking(0, [])
        return res

131、分割回文串（*）

image-20231123151758868

本题递归结束的条件是当startindex==字符串s 的长度时，往结果集中添加数据并返回。

递归的参数是startindex，和path，需要进行递归的字符串为s[startindex:i+1]进行切片，同时本题要求是回文子串，所以还需要加上判断是否是回文数字，如果是回文数字才进行回溯，不是回文数字的话不进行任何操作。

在递归体部分，需要一个for循环，其遍历范围是startindex到len(s)，然后往path列表中添加的元素是s[startindex:i+1]，这里注意字符串的切片是左闭右开的，因此这里区间是i+1，然后递归进行遍历backtracking(s,i+1,path)，注意这里的startindex需要从i+1开始，这是因为根据题目的要求，不会有重复出现的子串。

在**【39、组合总数】**一题中，题目说明candidates中的元素是可以重复出现的，因此我们在进行递归的时候传入的startindex就为for循环遍历的层数i，这样就可以一直递归下去找到符合条件的答案。但是本题中不能出现重复的所以传入的参数是i+1

递归三要素

  • 参数和返回值
def backtracking(s, startindex, path):
  • 递归终止条件
if startindex==len(s):
    res.append(path[:])
    return
  • 递归体 单层搜索过程
for i in range(startindex,len(s)):
    if huiwen(s[startindex:i+1]):
        path.append(s[startindex:i+1])
        backtracking(s,i+1,path)
        path.pop()

全部代码：

class Solution:
    def partition(self, s: str) -> List[List[str]]:
        res = []
        def backtracking(s,startindex,path):
            # print(startindex)
            # 如果分割到字符串末尾，则该轮结束
            if len(s)==startindex:
                res.append(path[:])
            
            for i in range(startindex,len(s)):
                # print(s[startindex:i+1])
                # 如果不是回文子串 不往path中添加
                if huiwen(s[startindex:i+1]):
                    path.append(s[startindex:i+1])
                    backtracking(s,i+1,path)
                    path.pop()
        
        def huiwen(s):
            return True if s==s[::-1] else False
            # i = 0
            # j = len(s)-1
            # while i<j:
            #     if s[i]!=s[j]:
            #         return False
            #     i+=1
            #     j-=1
            # return True
        
        backtracking(s,0,[])
        return res

image-20231125170244551

93、复原IP地址（*）

image-20231123215751666

image-20231123215802814

本题与分割字符串有几分相似，也属于分割问题。

递归三要素

  • 递归参数

字符串s，startindex和pointNum

pointNum表示IP地址中的.，如果有三个.的话，就说明当前的IP地址已经被分成四段了。

  • 递归结束的条件

根据本题要求，只要我们当前的字符串已经被分割成四段，即pointNum==3的时候，往res列表中添加结果并返回

  • 单层递归体中的操作
for i in range(startindex, len(s)):
    # IP 地址合法性剪枝
    if isValid(s[startindex:i+1]):
        sub = s[startindex:i+1]
        # 这里不能直接修改 path，而是使用一个副本进行传参
        backtracking(i + 1, path + sub + ".", pointNum + 1)
        else:
            break

img

校验逻辑：

  • 每一段以0开头则不合法
  • 每一段有非正整数数字不合法
  • 每一段数字如果大于255则不合法
def isValid(s):
    if len(s) == 0 or (s[0] == "0" and len(s) > 1) or int(s) > 255:
        return False
    return True

完整代码

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

        def backtracking(startindex, path, pointNum):
            # 长度剪枝
            if len(s) - startindex > (4 - pointNum) * 3:
                return
            if len(s) - startindex < (4 - pointNum):
                return
            
            if pointNum == 3:
                if isValid(s[startindex:]):
                    res.append(path + s[startindex:])
                return
            
            for i in range(startindex, len(s)):
                # IP 地址合法性剪枝
                if isValid(s[startindex:i+1]):
                    sub = s[startindex:i+1]
                    # 这里不能直接修改 path，而是使用一个副本进行传参
                    backtracking(i + 1, path + sub + ".", pointNum + 1)
                else:
                    break
                
        def isValid(s):
            if len(s) == 0 or (s[0] == "0" and len(s) > 1) or int(s) > 255:
                return False
            return True

        backtracking(0, "", 0)
        return res

78、子集

image-20231124100225029

思路：

如果把子集问题抽象成一颗树的话，组合问题和分割问题都是收集树的叶子结点，子集问题是找树的所有结点。

78.子集

子集是无序的，{1,2}和{2,1}是等价的，也就是说之前取过的元素后面不会再取，因此在递归的过程中还需要传递一个参数startindex，每次都是从startindex继续往后进行搜索，而不是从0开始，如果是排列问题的话，for循环就要从0开始了，因为在排列中{1,2}和{2,1}是两个不一样的排列。

class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:
        res = []
        def backtracking(nums,startindex,path):
            res.append(path[:])
            # 这里不需要加递归结束的条件，当startindex达到len(nums)的时候程序也就自动返回了
            for i in range(startindex,len(nums)):
                path.append(nums[i])
                backtracking(nums,i+1,path)
                path.pop()
        backtracking(nums,0,[])
        return res

90、子集II（*）

image-20231124101803120

本题和上一题的区别在于nums数组中可能包含重复元素，我们首先将其进行排序，然后在往res列表中添加数据的时候，进行判断只有不在res列表中的结果才能添加进去。其余部分和上一题一样。

  • 使用in操作去重
class Solution:
    def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
        # nums = list(set(nums))
        res = []

        def backtracking(nums, startindex, path):
            if path not in res:
                res.append(path[:])
            if startindex>len(nums):
                return
            for i in range(startindex,len(nums)):
                path.append(nums[i])
                backtracking(nums,i+1,path)
                path.pop()
        nums.sort()
        backtracking(nums,0,[])
        return res

本题是树层去重，在同一层重复出现的需要去除重复值；树层去重的话需要对数组进行排序。

90.子集II

  • 直接判断去重
class Solution:
    def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
        res = []

        def backtracking(startIndex, path):
            res.append(path[:])
            for i in range(startIndex, len(nums)):
                if i > startIndex and nums[i] == nums[i - 1]:
                    continue
                path.append(nums[i])
                backtracking(i + 1, path)
                path.pop()

        nums.sort()
        backtracking(0, [])
        return res
  • 使用used数组去重（推荐）
class Solution:
    def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
        res = []
        used = [False]*len(nums)

        def backtracking(nums,startindex,path,used):
            res.append(path[:])
            if startindex > len(nums):
                return 
            for i in range(startindex,len(nums)):
                if i>0 and nums[i]==nums[i-1] and not used[i-1]:
                    continue
                used[i] = True
                path.append(nums[i])
                backtracking(nums,i+1,path,used)
                used[i] = False
                path.pop()
        nums.sort()
        backtracking(nums,0,[],used)
        return res

90.子集II

491、递增子序列（*）

image-20231124211319729

本题需要再输入的序列中找到全部的递增子序列，同时需要注意的是题目中输入的数组会包含重复的元素，并且说明如果出现两个整数相等也会看作是递增序列的一种特殊情况。

利用回溯的思路，我们写出递归的三要素：

  • 参数和返回值

参数有：startindex用于记录下一层遍历的起始位置； path 用于记录结果列表

def backtracking(startindex, path):
  • 递归终止条件

题目中要求递增子序列中至少2个元素，因此可以判断如果len(path)>1则往res列表中添加结果并返回

这里需要注意，不能加return，加上了return的话，就会导致同一个树枝上的其他结果不能得到保存，这点类似于子集问题，子集问题是需要寻找叶子上的节点。

if len(path)>1:
    res.append(path[:])
    # return
  • 单层搜索逻辑

本题需要寻找递增子序列，不像之前的题目可以直接通过排序解决去重问题，因此需要使用另一种去重的方式，使用python中的集合，在Python中集合也是一个哈希表，可以在O(1)时间复杂度查询到想要的结果。

这里注意条件是和递增是或者or的关系的，即如果该数字已经在uset中，说明已经使用过了，需要跳过该数字。

同时uset是在每一层都会重新进行定义的，uset只会负责本层的结果。同一个父节点下的一层内如果出现重复数字则直接跳过

这里的一层指的是节点拥有同一个父节点

491. 递增子序列1

uset = set()
for i in range(startindex, len(nums)):
    if (path and path[-1]>=nums[i]) or nums[i] in uset:
        continue
    uset.add(nums[i])
    path.append(nums[i])
    backtracking(nums,i+1,path)
    path.pop()

完整代码：

class Solution:
    def findSubsequences(self, nums: List[int]) -> List[List[int]]:
        res = []

        def backtracking(startIndex, path):
            if len(path) > 1:
                res.append(path[:])
            uset = set()
            for i in range(startIndex, len(nums)):
                if (path and path[-1] > nums[i]) or nums[i] in uset:
                    continue
                uset.add(nums[i])
                path.append(nums[i])
                backtracking(i + 1, path)
                path.pop()

        backtracking(0, [])
        return res

image-20231124213406251

46、全排列

image-20231124214516935

全排列和组合问题、切割问题以及子集问题的区别就在于每次遍历都需要从0开始，而不是传进来的startindex，也就是说全排列问题中是不需要startindex的。

另外在之前的几种问题中，有几个我们传入参数不是i+1而是i的，这是因为题目中说明可以出现重复元素。如果要求是不能出现重复元素的话，只能传入i+1。

本题中因为下标都是从0开始进行遍历的，所以就需要记录哪些数字之前已经被使用过了，所以这里有两个方法：

  • 使用used数组进行记录
  • 使用uset集合进行记录

上面的这两种方法都需要在函数的参数中进行传递

递归三部曲

  • 参数和返回值
def backtracking(path,used):
  • 递归终止条件
if len(path)==len(nums):
    res.append(path[:])
    return
  • 单层搜索逻辑
for i in range(0, len(nums)):
    if used[i]:
    	continue
    used[i]=True
    path.append(nums[i])
    backtracking(nums,path)
    used[i]=False
    path.pop()

完整代码：

class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        res = []
        used = [False] * len(nums)

        def backtracking(path, used):
            if len(path) == len(nums):
                res.append(path[:])
                return
            for i in range(len(nums)):
                if used[i]:
                    continue
                used[i] = True
                path.append(nums[i])
                backtracking(path, used)
                path.pop()
                used[i] = False

        backtracking([], used)
        return res

image-20231125112358453

使用uset集合避免使用个重复的数组

class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        res = []

        def backtracking(path, uset):
            if len(path) == len(nums):
                res.append(path[:])
                return
            for i in range(len(nums)):
                if nums[i] in uset:
                    continue
                uset.add(nums[i])
                path.append(nums[i])
                backtracking(path, uset)
                uset.remove(path.pop())

        backtracking([], set())
        return res

image-20240319092628141

47、全排列II（*）

image-20231124215605773

本题因为nums中包含重复的数字，因此需要去重，去重的时候因为需要判断相邻的两个数是否相等，所以在一开始需要对nums进行排序。【排序和重复数字去重是一个配套操作需要一起来】

之后本题的和全排列的区别就在于需要判断相邻的两数是否相等并且前一个数是否没有用过。

for循环是横向遍历，递归是纵向遍历（即沿着树枝进行遍历的效果）

img

used数组主要使用来记录哪些元素已经使用过了，全排列问题中元素不能重复使用，每个元素都只能适用一次。

class Solution:
    def permuteUnique(self, nums: List[int]) -> List[List[int]]:
        res = []

        def backtracking(path, used):
            if len(path) == len(nums):
                res.append(path[:])
                return

            for i in range(len(nums)):
                if i > 0 and nums[i] == nums[i - 1] and not used[i - 1]:
                    continue
                if used[i]:
                    continue
                path.append(nums[i])
                used[i] = True
                backtracking(path, used)
                path.pop()
                used[i] = False

        nums.sort()
        backtracking([], [False] * len(nums))
        return res

组合问题和排列问题是在树形结构的叶子结点上收集结果，而子集问题就是取树上所有结点的结果。

and not used[i - 1]这部分代码是用来跳过重复的数字，如果前一个数字没有被选取，并且和当前数字值一致，则可以跳过这部分，这样的操作可以避免答案中出现重复的值。

使用uesd数组进行去重：
img

class Solution:
    def permuteUnique(self, nums: List[int]) -> List[List[int]]:
        res = []
        used = [False] * len(nums)

        def backtracking(path, used):
            if len(path) == len(nums):
                res.append(path[:])
                return

            for i in range(len(nums)):
                if i>0 and nums[i]==nums[i-1] and not used[i-1]:
                    continue
                if used[i]:
                    continue
                used[i] = True
                path.append(nums[i])
                backtracking(path, used)
                used[i] = False
                path.pop()

        nums.sort()
        backtracking([], used)
        return res

image-20231125112843814

784、字母大小写全排列

322、重新安排行程（hard)

image-20231127103728274

51、N皇后

image-20231127111457348

递归参数

定义res来存放最终的结果，n棋盘大小，row记录当前遍历到棋盘的第几层

递归终止条件

51.N皇后

当递归到叶子结点的时候就可以收集结果了。

if row==n:
    res.append(chessboard)
    return ;

单层递归逻辑

遍历这个棋盘的每一行，在python中，二维数组的表示就用嵌套列表表示即可。

验证棋盘是否合法

  • 皇后不能同行
  • 皇后不能同列
  • 皇后不能斜对角线（45度和135度）
def isValid(row, col, chessboard):
            # 列检查
            for i in range(row):
                if chessboard[i][col] == "Q":
                    return False
            # 45°角检查 这里的检查是从row col往前找
            i,j = row-1,col-1
            while i>=0 and j>=0:
                if chessboard[i][j] == "Q":
                    return False
                i-=1
                j-=1
            
            # 135°角检查
            i,j = row-1, col+1
            while i>=0 and j<len(chessboard):
                if chessboard[i][j]=="Q":
                    return False
                i -= 1
                j += 1
            return True

class Solution:
    def solveNQueens(self, n: int) -> List[List[str]]:    
        def backtracking(n,row,chessboard):
            # 递归终止的条件 当递归参数row==n时就进行发返回 并将结果添加到res中
            if row==n:
                res.append(chessboard[:])
                return
            # 对棋盘的每一行进行操作 判断是否合法
            for col in range(n):
                if isValid(row,col,chessboard):
                    chessboard[row] = chessboard[row][:col] + "Q" + chessboard[row][col+1:]
                    backtracking(n,row+1,chessboard)
                    chessboard[row] = chessboard[row][:col] + "." + chessboard[row][col+1:]
        
        def isValid(row, col, chessboard):
            # 列检查
            for i in range(row):
                if chessboard[i][col] == "Q":
                    return False
            # 45°角检查 这里的检查是从row col往前找
            i,j = row-1,col-1
            while i>=0 and j>=0:
                if chessboard[i][j] == "Q":
                    return False
                i-=1
                j-=1
            
            # 135°角检查
            i,j = row-1, col+1
            while i>=0 and j<len(chessboard):
                if chessboard[i][j]=="Q":
                    return False
                i -= 1
                j += 1
            

            return True
        
        res = []
        chessboard = ["."*n for _ in range(n) ]
        print(chessboard)
        backtracking(n,0,chessboard)
        return res

解数独

回溯总结

需要startIndex的题目有：

需要return的情况有：

一般情况下，如果题目中要求不能出现重复的数据，需要搭配这used数组进行使用，除此之外还需要对集合进行一个排序，这样可以在值相同的情况下进行判断。

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

used[i-1]==False 说明在同一层的前面结点已经使用过该数据了，后面不需要重复进行操作。

如果集合中存在重复的数字序列，则需要对其进行排序

  • 组合总数II
  • 子集II
  • 全排列II

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1595049.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

计算机网络 实验指导 实验17

计算机网络 实验指导 实验17

实验17 配置无线网络实验 1.实验拓扑图 Table PC0 和 Table PC1 最开始可能还会连Access Point0&#xff0c;无影响后面会改 名称接口IP地址网关地址Router0fa0/0210.10.10.1fa0/1220.10.10.2Tablet PC0210.10.10.11Tablet PC1210.10.10.12Wireless互联网220.10.10.2LAN192.16…
阅读更多...
CSS-布局

CSS-布局

display display 属性是用于控制 布局 的最重要的 CSS 属性。display 属性规定是否/如何显示元素。 每个 HTML 元素都有一个默认的 display 值&#xff0c;具体取决于它的元素类型。大多数元素的默认 display 值为 block 或 inline。 block block&#xff1a;块级元素。块级…
阅读更多...
STL--list双向链表

STL--list双向链表

功能 将数据进行链式存储 链表&#xff08;list&#xff09;是一种物理存储单元上非连续的存储结构&#xff0c;数据元素的逻辑顺序是通过链表中的指针链接实现的 链表的组成&#xff1a;链表由一系列结点组成 结点的组成&#xff1a;一个是存储数据元素的数据域&#xff0…
阅读更多...
Java应用中文件上传安全性分析与安全实践

Java应用中文件上传安全性分析与安全实践

✨✨谢谢大家捧场&#xff0c;祝屏幕前的小伙伴们每天都有好运相伴左右&#xff0c;一定要天天开心哦&#xff01;✨✨ &#x1f388;&#x1f388;作者主页&#xff1a; 喔的嘛呀&#x1f388;&#x1f388; 目录 引言 一. 文件上传的风险 二. 使用合适的框架和库 1. Spr…
阅读更多...
Tomcat服务器入门介及用postman工具简单接收数据 2024详解

Tomcat服务器入门介及用postman工具简单接收数据 2024详解

Tomcat服务器 简介 Tomcat是一个开源的Servlet容器&#xff0c;也是一个支持Java Servlet和JSP技术的Web服务器。它由Apache软件基金会开发和维护。Tomcat的主要作用是将Java Servlet和JavaServer Pages&#xff08;JSP&#xff09;等动态网页技术部署到服务器上&#xff0c;…
阅读更多...
Linux操作系统中关于用户管理的操作

Linux操作系统中关于用户管理的操作

创建新用户 useradd 【选项】 用户名 在/etc/passwd中以追加的方式在passwd的最后一行添加用户信息。 可以使用命令tail -n 1/etc/passwd查看文件的最后一行内容。 ls /home/首先/home/这是普通用户的家目录&#xff0c; 在/home/下会有一个跟用户名同名的家目录&#xf…
阅读更多...
推荐一款基于vim的超可扩展文本编辑器neovim

推荐一款基于vim的超可扩展文本编辑器neovim

一、简介 Vim是一个基于流行的Vi编辑器的文本编辑器&#xff0c;最初是在20世纪70年代发布的。Vim代表“改进的Vi”&#xff0c;它拥有广泛的用户基础和广泛的可用插件和扩展。 Neovim是Vim的一个分支&#xff0c;创建于2014年&#xff0c;旨在解决Vim的一些缺点&#xff0c;…
阅读更多...
Node.js留言板（超详细注释）

Node.js留言板（超详细注释）

目录结构如下 app.js // 一.引入模块 var http require(http);// 用于创建 HTTP 服务器和处理 HTTP 请求 var fs require(fs);// 用于读取和写入文件 var url require(url);// 用于解析URL// 创建留言数据对象 var msgs [{ name: 牛二, content: "我是妞儿", cr…
阅读更多...
Hadoop+Spark大数据技术（微课版）曾国荪、曹洁版思维导图第四次作业 （第4章 HBase分布式DB）

Hadoop+Spark大数据技术（微课版）曾国荪、曹洁版思维导图第四次作业 （第4章 HBase分布式DB）

1.简述Hbase的特点及与传统关系数据库的区别 HBase与传统关系数据库的区别 &#xff08;1&#xff09;数据类型 关系数据库具有丰富的数据类型&#xff0c;如字符串型、数值型、日期型、二进制型等。HBase只有字符串数据类型&#xff0c;数据的实际类型都是交由用户自己编写程序…
阅读更多...
Spring+SpringMVC的知识总结

Spring+SpringMVC的知识总结

一:技术体系架构二:SpringFramework介绍三:Spring loC容器和核心概念3.1 组件和组件管理的概念3.1.1什么是组件:3.1.2:我们的期待3.1.3Spring充当组件管理角色(IOC)3.1.4 Spring优势3.2 Spring Ioc容器和容器实现3.2.1普通和复杂容器3.2.2 SpringIOC的容器介绍3.2.3 Spring IOC…
阅读更多...
开源版中文和越南语贷款源码贷款平台下载 小额贷款系统 贷款源码运营版

开源版中文和越南语贷款源码贷款平台下载 小额贷款系统 贷款源码运营版

后台 代理 前端均为vue源码&#xff0c;前端有中文和越南语 前端ui黄色大气&#xff0c;逻辑操作简单&#xff0c;注册可对接国际短信&#xff0c;可不对接 用户注册进去填写资料&#xff0c;后台审批&#xff0c;审批状态可自定义修改文字显示 源码免费下载地址抄笔记 (chaob…
阅读更多...
【Vue】新手一步一步安装 vue 语言开发环境

【Vue】新手一步一步安装 vue 语言开发环境

文章目录 1、下载node.js安装包 1、下载node.js安装包 1.打开node.js的官网下载地址&#xff1a;http://nodejs.cn/download/ 选择适合自己系统的安装包&#xff1a;winds、mac 2. 配置node.js和npm环境变量 安装好之后&#xff0c;对npm安装的全局模块所在路径以及缓存所在路…
阅读更多...
Linux网络基础 (二) ——(IP、MAC、端口号、TCPUDP协议、网络字节序)

Linux网络基础 (二) ——(IP、MAC、端口号、TCPUDP协议、网络字节序)

文章目录 IP 地址基本概念源IP地址 & 目的IP地址 MAC 地址基本概念源MAC地址 & 目的MAC地址 端口号基本概念源端口号 & 目的端口号 TCP & UDP 协议基本概念TCP 与 UDP 的抉择 网络字节序大端、小端字节序 &#x1f396; 博主的CSDN主页&#xff1a;Ryan.Alask…
阅读更多...
五、Jenkins、Docker、SpringClound持续集成

五、Jenkins、Docker、SpringClound持续集成

Jenkins、Docker、SpringClound持续集成 一、部署介绍1.部署图2.微服务项目结构3.项目启动顺序 二、微服务项目在Windows运行1.配置java、maven环境2.初始化数据库表/数据2.1 tensquare_gathering服务表2.2 tensquare_gathering服务表 3.启动微服务4.微服务接口测试4.1 获取用户…
阅读更多...
Tomcat源码解析——Tomcat的启动流程

Tomcat源码解析——Tomcat的启动流程

一、启动脚本 当我们在服务启动Tomcat时&#xff0c;都是通过执行startup.sh脚本启动。 在Tomcat的启动脚本startup.sh中&#xff0c;最终会去执行catalina.sh脚本&#xff0c;传递的参数是start。 在catalina.sh脚本中&#xff0c;前面是环境判断和初始化参数&#xff0c;最终…
阅读更多...
架构师系列-搜索引擎ElasticSearch（六）- 映射

架构师系列-搜索引擎ElasticSearch（六）- 映射

映射配置 在创建索引时&#xff0c;可以预先定义字段的类型&#xff08;映射类型&#xff09;及相关属性。 数据库建表的时候&#xff0c;我们DDL依据一般都会指定每个字段的存储类型&#xff0c;例如&#xff1a;varchar、int、datetime等&#xff0c;目的很明确&#xff0c;就…
阅读更多...
45.HarmonyOS鸿蒙系统 App(ArkUI)创建列表（List）

45.HarmonyOS鸿蒙系统 App(ArkUI)创建列表（List）

列表是一种复杂的容器&#xff0c;当列表项达到一定数量&#xff0c;内容超过屏幕大小时&#xff0c;可以自动提供滚动功能。它适合用于呈现同类数据类型或数据类型集&#xff0c;例如图片和文本。在列表中显示数据集合是许多应用程序中的常见要求&#xff08;如通讯录、音乐列…
阅读更多...
Qt快速入门（MV架构之TableView + QStandardItemModel + 自定义代理小案例）

Qt快速入门（MV架构之TableView + QStandardItemModel + 自定义代理小案例）

Qt快速入门&#xff08;MV架构之TableView QStandardItemModel 自定义代理小案例&#xff09; 关于MV架构的简单介绍 在Qt框架中&#xff0c;代理&#xff08;Delegate&#xff09;、模型&#xff08;Model&#xff09;和视图&#xff08;View&#xff09;之间的关系构成了…
阅读更多...
14_SpringMVC

14_SpringMVC

文章目录 MVCSpringMVC与JavaEE对比SpringMVCSpringMVC的核心流程SpringMVC入门案例RequestMapping注解的使用Handler方法的返回值Handler方法的形参keyvalue形式的请求参数Json请求参数 RESTful风格接口静态资源处理FilterHandlerInterceptor异常处理SpringMVC核心流程流程图 …
阅读更多...
自动化收集Unity版本更新日志

自动化收集Unity版本更新日志

自动化收集Unity版本更新日志 &#x1f365;功能介绍&#x1f96a;食用手册填写配置开始搜集 &#x1f368;数据展示 &#x1f365;功能介绍 &#x1f4a1;获取指定年份中所有的Unity版本更新日志。 &#x1f4a1;根据指定字符串过滤。 &#x1f4a1;.收集后自动保存成markdow…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023