珍宝鸭的力扣练习（5）：深度优先搜索递归法（DFS）

最新推荐文章于 2021-12-13 17:15:54 发布

珍宝鸭

最新推荐文章于 2021-12-13 17:15:54 发布

阅读量666

点赞数 1

分类专栏：笔记

本文链接：https://blog.csdn.net/qq_38138689/article/details/105045430

版权

笔记专栏收录该内容

16 篇文章 0 订阅

订阅专栏

题目列表：

题型1：N叉树
题型2：矩阵
题型3：链表
- 1.复制复杂链表
- 2.二叉树转双向链表
题型4：字符串
- 1.字符串的排列

题型1：N叉树

1. 2叉树合为num的路径（首位固定）

输入一棵二叉树和一个整数，打印出二叉树中节点值的和为输入整数的所有路径。从树的根节点开始往下一直到叶节点所经过的节点形成一条路径。在这里插入图片描述

class Solution(object):
    def pathSum(self, root, num):
        def DFS(r,pre_lst):
            if r==None: return
            pre_lst.append(r.val)
            if  (sum(pre_lst)==num) and  r.left==None and  r.right==None :
                    result.append(pre_lst)
                    return 
            mid=pre_lst[:]
            DFS(r.left,pre_lst)
            DFS(r.right,mid)

        result=[]
        pre_lst=[]
        DFS(root,pre_lst)
        return result

class Solution:
    def pathSum(self, root: TreeNode, sum: int) -> List[List[int]]:
        res, path = [], []
        def recur(root, tar):
            if not root: return
            path.append(root.val)
            tar -= root.val
            if tar == 0 and not root.left and not root.right:
                res.append(list(path))
            recur(root.left, tar)
            recur(root.right, tar)
            path.pop()

        recur(root, sum)
        return res

2. 2叉树合为num的路径（首位不固定）

路径被定义为一条从树中任意节点出发，沿父节点-子节点连接，达到任意节点的序列。同一个节点在一条路径序列中至多出现一次。
该路径至少包含一个节点，且不一定经过根节点。路径和是路径中各节点值的总和。给你一个二叉树的根节点 root ，返回其最大路径和。

class Solution:
    def __init__(self):
        self.maxSum = float("-inf")

    def maxPathSum(self, root: TreeNode) -> int:
        def maxGain(node):
            if not node:
                return 0
            # 递归计算左右子节点的最大贡献值
            # 只有在最大贡献值大于 0 时，才会选取对应子节点
            leftGain = max(maxGain(node.left), 0)
            rightGain = max(maxGain(node.right), 0)
            
            # 节点的最大路径和取决于该节点的值与该节点的左右子节点的最大贡献值
            priceNewpath = node.val + leftGain + rightGain
            
            # 更新答案
            self.maxSum = max(self.maxSum, priceNewpath)
        
            # 返回节点的最大贡献值
            return node.val + max(leftGain, rightGain)
   
        maxGain(root)
        return self.maxSum

3. 2叉树第k大节点

给定一棵二叉搜索树，请找出其中第k大的节点。
题解：根据以上性质，易得二叉搜索树的 中序遍历倒序 为 递减序列 。
因此，求 “二叉搜索树第 k 大的节点” 可转化为求 “此树的中序遍历倒序的第 k 个节点”。

class Solution(object):
    def kthLargest(self, root, k):
        self.k=k
        def DFS(cur):
            if not cur or self.k<=0: return
            DFS(cur.right)
            self.k-=1
            if self.k==0:
                self.result=cur.val
            DFS(cur.left) 
        DFS(root)
        return  self.result

3. 是否为平衡二叉树

输入一棵二叉树的根节点，判断该树是不是平衡二叉树。如果某二叉树中任意节点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。
题解：基于求解二叉树最大深度的题目思路：
此树的深度等于左子树的深度与右子树的深度中的最大值 +1 。
添加如下条件：
左子树深度与右子树深度相差大于1时：此树深度为-1

class Solution(object):
    def maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        self.depth=0
        def DFS(root,depth):
            if not root: return 
            depth+=1
            self.depth=max(self.depth,depth)
            if root.left or root.right:
                DFS(root.left,depth)
                DFS(root.right,depth)
        DFS(root,0)
        return self.depth

题型2：矩阵

1. 矩阵中的路径

请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一格开始，每一步可以在矩阵中向左、右、上、下移动一格。如果一条路径经过了矩阵的某一格，那么该路径不能再次进入该格子。例如，在下面的3×4的矩阵中包含一条字符串“bfce”的路径（路径中的字母用加粗标出）。

[[“a”,“b”,“c”,“e”],
[“s”,“f”,“c”,“s”],
[“a”,“d”,“e”,“e”]]

但矩阵中不包含字符串“abfb”的路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入这个格子。

输入：board = [[“A”,“B”,“C”,“E”],[“S”,“F”,“C”,“S”],[“A”,“D”,“E”,“E”]], word = “ABCCED”
输出：true

题解：DFS 通过递归，先朝一个方向搜到底，再回溯至上个节点，沿另一个方向搜索，以此类推。
递归参数：当前元素在矩阵 board 中的行列索引 i 和 j ，当前目标字符在 word 中的索引 k 。
终止条件：
返回 false ： (1) 行或列索引越界或 (2) 当前矩阵元素与目标字符不同或 (3) 当前矩阵元素已访问过（ (3) 可合并至 (2) ）。
返回 true ： k = len(word) - 1 ，即字符串 word 已全部匹配。
递推工作：
标记当前矩阵元素：将 board[i][j] 修改为空字符 ‘’ ，代表此元素已访问过，防止之后搜索时重复访问。
搜索下一单元格：朝当前元素的上、下、左、右四个方向开启下层递归，并记录结果至 res 。
还原当前矩阵元素：将 board[i][j] 元素还原至初始值，即 word[k] 。

鸭子写法

class Solution(object):
    def exist(self, board, word):
        """
        :type board: List[List[str]]
        :type word: str
        :rtype: bool
        """
        self.flag=False
        def DFS(i,j,k):
            if board[i][j]==word[k]:

                if k==len(word)-1:
                    self.flag=True
                else:
                    board[i][j]=''
                    if i-1>=0 :
                      DFS(i-1,j,k+1)
                    if i+1<=len(board)-1:
                      DFS(i+1,j,k+1)
                    if j-1>=0 :
                      DFS(i,j-1,k+1)
                    if j+1<=len(board[0])-1 :
                      DFS(i,j+1,k+1)
                    if self.flag==False:
                        board[i][j]=word[k]

        for i in range(len(board)):
            for j in range(len(board[0])):
                k = 0  # 标记是第几个字母
                DFS(i,j,k)
                if self.flag==True:
                    return True
        return False

2. 岛屿的最大面积

给定一个包含了一些 0 和 1 的非空二维数组 grid 。
一个岛屿是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在水平或者竖直方向上相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。

找到给定的二维数组中最大的岛屿面积。(如果没有岛屿，则返回面积为 0 。)
例如：
[[0,0,1,0,0,0,0,1,0,0,0,0,0],
[0,0,0,0,0,0,0,1,1,1,0,0,0],
[0,1,1,0,1,0,0,0,0,0,0,0,0],
[0,1,0,0,1,1,0,0,1,0,1,0,0],
[0,1,0,0,1,1,0,0,1,1,1,0,0],
[0,0,0,0,0,0,0,0,0,0,1,0,0],
[0,0,0,0,0,0,0,1,1,1,0,0,0],
[0,0,0,0,0,0,0,1,1,0,0,0,0]]
题解：DFS 通过递归，先朝一个方向搜到底，再回溯至上个节点，沿另一个方向搜索，以此类推。

class Solution:
    def maxAreaOfIsland(self, grid: List[List[int]]) -> int:
        m, n = len(grid), len(grid[0])
        def dfs(gird, i, j):
            if 0<=i<m and  0<=j<n and grid[i][j]:
                grid[i][j] = 0
                return 1 + dfs(grid, i+1,j) + dfs(grid, i-1, j) + dfs(grid, i, j+1) + dfs(grid, i, j-1)
            return 0
        result = 0
        for x in range(m):
            for y in range(n):
                result = max(result, dfs(grid, x, y))
        return result

模板

class Solution:
    def exist(self, board: List[List[str]], word: str) -> bool:
        def dfs(i, j, k):
            if not 0 <= i < len(board) or not 0 <= j < len(board[0]) or board[i][j] != word[k]: return False
            if k == len(word) - 1: return True
            board[i][j] = ''
            res = dfs(i + 1, j, k + 1) or dfs(i - 1, j, k + 1) or dfs(i, j + 1, k + 1) or dfs(i, j - 1, k + 1)
            board[i][j] = word[k]
            return res

        for i in range(len(board)):
            for j in range(len(board[0])):
                if dfs(i, j, 0): return True
        return False

3. 机器人行走范围

地上有一个m行n列的方格，从坐标 [0,0] 到坐标 [m-1,n-1] 。一个机器人从坐标 [0, 0] 的格子开始移动，它每次可以向左、右、上、下移动一格（不能移动到方格外），也不能进入行坐标和列坐标的数位之和大于k的格子。例如，当k为18时，机器人能够进入方格 [35, 37] ，因为3+5+3+7=18。但它不能进入方格 [35, 38]，因为3+5+3+8=19。请问该机器人能够到达多少个格子？

输入：m = 2, n = 3, k = 1
输出：3

class Solution:
    def movingCount(self, m, n, k) :
        def judge(i ,j):
            mid=0
            while i>0:
                mid+=i%10
                i=i//10

            while j>0:
                mid+=j%10
                j=j//10

            return True if mid<=k else False
        def DFS(i,j):
            if judge(i,j):
                if [i,j] not in vis:
                    vis.append([i,j])

                if i-1>=0 and  [i-1,j] not in vis:
                    DFS(i-1,j)
                if j-1>=0 and  [i,j-1] not in vis:
                    DFS(i,j-1)
                if i+1<=m-1 and  [i+1,j] not in vis:
                    DFS(i+1, j)
                if j+1<=n-1 and  [i,j+1] not in vis:
                    DFS(i, j +1)

        vis = []
        DFS(0,0)
        return len(vis)

模板

def movingCount(self, m, n, k):

    visited=[] #定义标记访问状态
    return self.DFS(0,0,m,n,visited,k) #初始状态是原点

def DFS(self,i,j,k):

    if i<0 or i>=m or j<0 or j>=n or self.cal(i)+self.cal(j)>k or [i,j] in visited: #边界条件
        return 0

    visited.append([i,j])
    #回溯子状态
    return self.DFS(i-1,j,m,n,visited,k)+self.DFS(i,j-1,m,n,visited,k)+self.DFS(i+1,j,m,n,visited,k)+self.DFS(i,j+1,m,n,visited,k)+1
    

def cal(self,num): #计算行坐标和列坐标数位和

    total=0
    while num>0:
        total+=num%10
        num//=10
    return total

题型3：链表

1.复制复杂链表

请实现 copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指向链表中的任意节点或者 null。

class Solution:
    def copyRandomList(self, head):
        def dfs(head):
            if not head: return None
            if head in visited:
                return visited[head]
            # 创建新结点
            copy = Node(head.val, None, None)
            visited[head] = copy
            copy.next = dfs(head.next)
            copy.random = dfs(head.random)
            return copy
        visited = {}
        return dfs(head)

图的基本单元是顶点，顶点之间的关联关系称为边，我们可以将此链表看成一个图：在这里插入图片描述
由于图的遍历方式有深度优先搜索和广度优先搜索，同样地，对于此链表也可以使用深度优先搜索和广度优先搜索两种方法进行遍历。

算法：深度优先搜索
从头结点 head 开始拷贝；
由于一个结点可能被多个指针指到，因此如果该结点已被拷贝，则不需要重复拷贝；
如果还没拷贝该结点，则创建一个新的结点进行拷贝，并将拷贝过的结点保存在哈希表中；
使用递归拷贝所有的 next 结点，再递归拷贝所有的 random 结点。

class Solution:
    def copyRandomList(self, head):
        def dfs(head):
            if not head: return None
            if head in visited:
                return visited[head]
            # 创建新结点
            copy = Node(head.val, None, None)
            visited[head] = copy
            copy.next = dfs(head.next)
            copy.random = dfs(head.random)
            return copy
        visited = {}
        return dfs(head)

2.二叉树转双向链表

输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的循环双向链表。要求不能创建任何新的节点，只能调整树中节点指针的指向。
在这里插入图片描述
我们希望将这个二叉搜索树转化为双向循环链表。链表中的每个节点都有一个前驱和后继指针。对于双向循环链表，第一个节点的前驱是最后一个节点，最后一个节点的后继是第一个节点。

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/er-cha-sou-suo-shu-yu-shuang-xiang-lian-biao-lcof著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
首先观察到题目给的是一棵二叉搜索树，这就意味着我们只需要用中序遍历就能实现排序的链表了。
最终得到的链表的头节点必然是二叉搜索树最左边的节点（题目示例中就是 1）；尾节点必然是二叉搜索树最右边的节点（题目示例中就是 5）。
我们先定义 *tail 和 *head，初始它们都是 null，到最后则会一个指向尾节点一个指向头节点。
所以我们中序遍历，首先 root 一直往左走，走到了最左边的 1 处，此时 tail 还是 null，并且整个遍历过程中只有这个时候 tail 会是 null。这个时候我们让 head = root，也就找到了链表的头节点。
然后我们更新 tail = root（也就是 1），root 会回溯到上一级也就是 2。这时我们就写 tail -> right = root; 和 root -> left = tail;。
我们此时接着更新 tail = root（也就是 2）。如此往复。
中序遍历走完之后，链表也就构造完了，除了 head 和 tail 之间的连接，我们再连接一下就好了。

"""
# Definition for a Node.
class Node(object):
    def __init__(self, val, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
"""
class Solution(object):
    def treeToDoublyList(self, root):
        def dfs(cur):
            if not cur: return
            dfs(cur.left) # 递归左子树
            if self.pre: # 修改节点引用
                self.pre.right, cur.left = cur, self.pre
            else: # 记录头节点
                self.head = cur
            self.pre = cur # 保存 cur
            dfs(cur.right) # 递归右子树
        
        if not root: return
        self.pre = None
        dfs(root)
        self.head.left, self.pre.right = self.pre, self.head
        return self.head

题型4：字符串

1.字符串的排列

输入一个字符串，打印出该字符串中字符的所有排列。
输入：s = “abc”
输出：[“abc”,“acb”,“bac”,“bca”,“cab”,“cba”]

题解:首先可以固定一个字母。当固定第一个字母时，有三种可能（a,b,c)。此时在剩下的序列里面在固定一个字母，直到固定字母的数量等于len(s)。
在这里插入图片描述
重复方案与剪枝：当字符串存在重复字符时，排列方案中也存在重复方案。为排除重复方案，需在固定某位字符时，保证 “每种字符只在此位固定一次” ，即遇到重复字符时不交换，直接跳过。从 DFS 角度看，此操作称为 “剪枝” 。
在这里插入图片描述

class Solution(object):
    def permutation(self, s):
        result=[]
        def DFS(pre,left):
            if not left:
                result.append(''.join(pre))
                return
            visited=[]
            for i in range(len(left)):
                if left[i] not in visited:
                    visited.append(left[i])
                    cur_pre,cur_left=pre[:],left[:]
                    cur_pre.append(left[i])
                    del cur_left[i]
                    DFS(cur_pre,cur_left)
        DFS([],list(s))
        return result