牛客——递归与回溯问题

哦啦啦啊哦哦

已于 2022-04-19 17:36:18 修改

阅读量796

点赞数 2

文章标签： python

于 2022-04-19 12:15:55 首次发布

本文链接：https://blog.csdn.net/qq_43108660/article/details/124268790

版权

文章目录

1.没有重复项数字的全排列

给出一组数字，返回该组数字的所有排列
例如：
[1,2,3]的所有排列如下
[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2], [3,2,1].
（以数字在数组中的位置靠前为优先级，按字典序排列输出。）

数据范围：数字个数 0 < n \le 60<n≤6
要求：空间复杂度 O(n!)O(n!) ，时间复杂度 O(n!）O(n!）

输入：[1,2,3]
返回值：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

class Solution:
    def permute(self , num: List[int]) -> List[List[int]]:
        # write code here
        if not num: return None
        num.sort()
        res=[]
        self.recall(0,num,res)
        return res
    def recall(self,first,num1,res):# 这个first给了才能确保现在是第几个 太难了 给我我也写不出来
        if first == len(num1)-1:
            res.append(num1)
        else:
            for i in range(first, len(num1)):
                num1[i], num1[first] = num1[first], num1[i]
                num2 = num1[:]
                self.recall(first+1, num2, res)

借助下一题的另一种方法

class Solution:
    def  permute(self , num: List[int]) -> List[List[int]]:
        # write code here
        if not num: return None
        res = []
        num.sort()
        def backtracck(num,temp):# 这个也好难
            if not num:
                res.append(temp)
                return
            for i in range(len(num)):
                backtracck(num[:i] + num[i+1:], temp+[num[i]])# num[:0]=[]
        backtracck(num, [])
        return res

2.有重复项数字的全排列

给出一组可能包含重复项的数字，返回该组数字的所有排列。结果以字典序升序排列。

数据范围： 0 < n \le 80<n≤8 ，数组中的值满足 -1 \le val \le 5−1≤val≤5
要求：空间复杂度 O(n!)O(n!)，时间复杂度 O(n!)O(n!)

输入：[1,1,2]
返回值：[[1,1,2],[1,2,1],[2,1,1]]

class Solution:
    def permuteUnique(self , num: List[int]) -> List[List[int]]:
        # write code here
        if not num: return None
        res = []
        num.sort()
        def backtracck(num,temp):# 这个也好难
            if not num:
                res.append(temp)
                return
            for i in range(len(num)):
                if i>0 and num[i] == num[i-1]:
                    continue
                backtracck(num[:i] + num[i+1:], temp+[num[i]])# num[:0]=[]
        backtracck(num, [])
        return res

3.岛屿数量（类似在找最大联通路径

给一个01矩阵，1代表是陆地，0代表海洋，如果两个1相邻，那么这两个1属于同一个岛。我们只考虑上下左右为相邻。
岛屿: 相邻陆地可以组成一个岛屿（相邻:上下左右）判断岛屿个数。
例如：
输入
[
[1,1,0,0,0],
[0,1,0,1,1],
[0,0,0,1,1],
[0,0,0,0,0],
[0,0,1,1,1]
]
对应的输出为3
(注：存储的01数据其实是字符’0’,‘1’)

输入：[
[1,1,0,0,0],
[0,1,0,1,1],
[0,0,0,1,1],
[0,0,0,0,0],
[0,0,1,1,1]
]

返回值：3

class Solution:
    def solve(self , grid: List[List[str]]) -> int:
        # write code here
        res,n,m=0,len(grid),len(grid[0])
        def replace(i,j):
            if 0<=i<n and 0<=j<m:
                if grid[i][j]=='1':# 这个判断不能删掉 删掉的话 递归就太多了 
                    # 虽然我在for里边已经直到他是1了 但是后面调用的时候不知道
                    grid[i][j]='0'
                    replace(i-1, j)
                    replace(i+1, j)
                    replace(i, j-1)
                    replace(i, j+1)
        num =0
        for i in range(n):
            for j in range(m):
                if grid[i][j] == '1':
                    num += 1
                    replace(i, j)
        return num

4.字符串的排列（这道题和排数组一样

输入一个长度为 n 字符串，打印出该字符串中字符的所有排列，你可以以任意顺序返回这个字符串数组。
例如输入字符串ABC,则输出由字符A,B,C所能排列出来的所有字符串ABC,ACB,BAC,BCA,CBA和CAB。

数据范围：n < 10n<10
要求：空间复杂度 O(n!)O(n!)，时间复杂度 O(n!)O(n!)
输入描述：
输入一个字符串,长度不超过10,字符只包括大小写字母。

示例1
输入：“ab”

返回值：[“ab”,“ba”]
返回[“ba”,“ab”]也是正确的

class Solution:
    def Permutation(self , str: str) -> List[str]:
        # write code here
        # 先求出可能出现的第一个字符 然后求第二个字符可能出现的情况
        # 简而言之就是 固定 变化 固定 变化
        # 那么我们就是可以用递归的
        # 但是有可能会有相同的 所以选择不同的时候 交换 这样会比较简单
        #（借助一个set 放现有的存在的元素 这样可以用xx in判断
        n=len(str)
        res=[]
        queue=list(str)# 因为字符串是不可交换的 所以先要把他转换为列表
        # 固定第X位上的字符
        def fix(x):# 简单点就是说这个是在固定第x个值
            # 递归结束的条件
            if x==n-1:
                res.append(''.join(queue))
                return
            seen=set()
            for i in range(x,n):# 当前x位和后面所有的交换
                if queue[i] in  seen:continue# 如果已经存在了 那么这次就不用管了
                seen.add(queue[i])# 因为是集合 所以就add
                queue[x] ,queue[i]=queue[i] ,queue[x]# 先交换
                fix(x+1)# 交换完就开始递归下一位
                queue[i] ,queue[x]=queue[x] ,queue[i]# 交换了 肯定还得交换回来 不然就会奇怪
                
        fix(0)
        return res

5.N 皇后问题

N 皇后问题是指在 n * n 的棋盘上要摆 n 个皇后，
要求：任何两个皇后不同行，不同列也不在同一条斜线上，
求给一个整数 n ，返回 n 皇后的摆法数。

数据范围: 1≤n≤9
要求：空间复杂度 O(1)，时间复杂度 O(n!)

例如当输入4时，对应的返回值为2，
对应的两种四皇后摆位如下图所示：
在这里插入图片描述

输入：1
返回值：1

输入：8
返回值：92

###########这个会超时
class Solution:
    def Nqueen(self , n: int) -> int:
        # write code here
        # 对角线 右下是x-y为同一值 左上是x+y是同一值
        matrix=[[0]*n]*n
        def check(x,y):
            for i in range(n):
                if matrix[i][y]==1:return False
            for i in range(n):
                for j in range(n):
                    if matrix[i][y]==1 and x-y==i-j:return False
            for i in range(n):
                for j in range(n):
                    if matrix[i][y]==1 and x+y==i+j:return False 
            return True

        def dfs(num,ans=0):
            if num==n:
                ans =ans +1
                return ans
            for i in range(n):
                if check(num,i):
                    matrix[num][i]=1
                    dfs(num+1)
                    matrix[num][i]=0             
        dfs(0)
        return ans

#这个不太看得懂
class Solution:
    def Nqueen(self , n ):
        if n==0 or n==1:
            return n
        limit=(1<<n)-1
        return self.Nqueen_recursion(limit,0,0,0)
    def Nqueen_recursion(self,limit,left,right,mid):
        if mid==limit:
            return 1
        pos= left | right|mid
        pos=(~pos) & limit
        res=0
        while pos >0: 
            rightestone=((~pos)+1)&pos
            res+=self.Nqueen_recursion(limit,(left|rightestone)<<1,(right|rightestone)>>1,mid|rightestone)
            pos-=rightestone
        return res

# 这个直接就是用col dia1 dia2 也就是列 左对角线 右对角线先放在set里边 然后开始递归
class Solution:
    def Nqueen(self , n ):
        # write code here
        col=set()
        dia1=set()
        dia2=set()
        self.ans=0
        def dfs(num,col,dia1,dia2):
            if num==n:
                self.ans+=1
            else:
                for j in range(n):
                    if j in col or num-j in dia1 or j+num in dia2:
                    #这里num-j num+j 就是在找对角线了
                        continue
                    col.add(j)
                    dia1.add(num-j)
                    dia2.add(j+num)
                    dfs(num+1,col,dia1,dia2)
                    col.remove(j)
                    dia1.remove(num-j)
                    dia2.remove(j+num)
        dfs(0,col,dia1,dia2)
        return self.ans

6.括号生成

给出n对括号，请编写一个函数来生成所有的由n对括号组成的合法组合。
例如，给出n=3，解集为：
“((()))”, “(()())”, “(())()”, “()()()”, “()(())”

数据范围：81≤n≤8

示例1
输入：1
返回值：["()"]

示例2
输入：2
返回值：["(())","()()"]

class Solution:
    def generateParenthesis(self , n: int) -> List[str]:
        # write code here
        if n <= 0: return []
        res = []
        def dfs(s, res, n, left, right):# left和right控制左右括号个数
            if left == n and right == n:
                res.append(s)
                return
            if left < n:# 这里他dfs后 还会往下走的 我自己肯定想不出来
                dfs(s+'(',res,n, left+1,right)
                # 进入循环之后 left<n做一遍 然后就跳到下面开始加右括号了
            if right < left:
                dfs(s+')',res,n,left, right+1)
        dfs('', res, n, 0, 0)
        return res

7.矩阵最长路径

给定一个 n 行 m 列矩阵 matrix ，矩阵内所有数均为非负整数。你需要在矩阵中找到一条最长路径，使这条路径上的元素是递增的。并输出这条最长路径的长度。
这个路径必须满足以下条件：

对于每个单元格，你可以往上，下，左，右四个方向移动。你不能在对角线方向上移动或移动到边界外。
你不能走重复的单元格。即每个格子最多只能走一次。

数据范围：1 \le n,m \le 10001≤n,m≤1000，0 \le matrix[i][j] \le 10000≤matrix[i][j]≤1000
进阶：空间复杂度 O(nm)O(nm) ，时间复杂度 O(nm)O(nm)

例如：当输入为[[1,2,3],[4,5,6],[7,8,9]]时，对应的输出为5，
其中的一条最长递增路径如下图所示：
在这里插入图片描述
示例1
输入：[[1,2,3],[4,5,6],[7,8,9]]
返回值：5
说明：1->2->3->6->9即可。当然这种递增路径不是唯一的。

示例2
输入：[[1,2],[4,3]]
返回值：4
说明： 1->2->3->4

step 1：既然是查找最长的递增路径长度，那我们首先要找到这个路径的起点，起点不好直接找到，就从上到下从左到右遍历矩阵的每个元素。
step 2：然后以每个元素都可以作为起点查找它能到达的最长递增路径，然后维护一个最大值。
step 3：如何查找以某个点为起点的最长递增路径呢？我们可以考虑递归，因此我们查找递增路径的时候，每次选中路径一个点，然后找到与该点相邻的递增位置，相当于进入这个相邻的点，继续查找递增路径，这就是递归的子问题。因此递归过程如下：

终止条件：进入路径最后一个点后，四个方向要么是矩阵边界，要么没有递增的位置，路径不能再增长，返回上一级。
返回值：每次返回的就是本级之后的子问题中查找到的路径长度加上本级的长度。
本级任务：每次进入一级子问题，先初始化后续路径长度为0，然后遍历四个方向（可以用数组表示，下标对数组元素的加减表示去往四个方向），进入符合不是边界且在递增的邻近位置作为子问题，查找子问题中的递增路径长度。因为有四个方向，所以最多有四种递增路径情况，因此要维护当级子问题的最大值。
step 4：使用一个dp数组记录i，j处的单元格拥有的最长递增路径，这样在递归过程中如果访问到就不需要重复访问。

class Solution:
    def solve(self , matrix: List[List[int]]) -> int:
        # write code here
        if not matrix or not matrix[0]:return 0
        m, n = len(matrix), len(matrix[0])
        # dp = [[0]*n]*m# 这个用来存储走过的路径
        dp = [[0]*n for _ in range(m)]# 上面那个方法不知道为啥不行
        res=0
        def dfs(i, j):
            if not dp[i][j]:#dp[i][j]为0就往下走
                val = matrix[i][j]
                dp[i][j] = 1 + max(
                    dfs(i-1, j) if i and val<matrix[i-1][j] else 0,
                    dfs(i+1, j) if i< m-1 and val<matrix[i+1][j] else 0,
                    dfs(i, j-1) if j and val< matrix[i][j-1] else 0,
                    dfs(i, j+1) if j< n-1 and val<matrix[i][j+1] else 0)
                # 上下左右判别一遍 并且这里还得弄一下 不要超出边界了
            return dp[i][j]
        return max(dfs(x,y) for x in range(m) for y in range(n))
        # 这里一定是不能改的 因为要做一次循环来完成所有的遍历