Python - 深夜数据结构与算法之 BFS & DFS

已于 2024-01-22 20:51:33 修改
阅读量1.8k 收藏 26
点赞数 48
分类专栏： 夜深人静写算法 Python 文章标签： 宽度优先 深度优先 算法 Python DFS BFS
于 2023-12-27 08:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BIT_666/article/details/135207412
版权

目录

一.引言

二.BFS 与 DFS 简介

1.Search 搜索

2.DFS 深度优先

3.BFS 广度优先

4.DFS & BFS

三.经典算法实战

1.Generate-Parentheses [22]

2.Level-Order-Travesal [102]

3.Word-Ladder [127]

4.Num-Of-Islands [200]

5.Min-Gene-Mutation [433]

6.Largest-Values [515]

7.Mine-Clearance [529]

四.总结

一.引言

BFS 广度优先搜索与 DFS 深度优先搜索是树以及网格等相关题目最常见的方法之一，其通过不同的遍历方式对分叉结构进行遍历，对于树、图而言，其可以是二叉、多叉，其可以是上下左右，下面让我们深入了解下 BFS 与 DFS。

二.BFS 与 DFS 简介

1.Search 搜索

不论是 BFS 还是 DFS，它们都是数据结构节点的访问方式，为了效率足够高，我们希望每个节点访问且仅访问一次，因而衍生出了 DFS - Depth First Search 深度优先搜索与 BFS - Breadth First Search 广度优先搜索两种遍历方式。除此之外还有按照节点优先级访问的算法，不过需要特定的场景才会使用。 

2.DFS 深度优先

深度优先搜索，我们前面提到的二叉树的前中后序遍历都是深度优先搜索的一种，对于二叉树而言，其深度搜索的路径是向 Left 左子树和 Right 右子树递进，多叉树的话则是其 Children 节点集合，对于图而言，则是其他相邻的点 V，其通式可以参照下面的写法。

◆ 递归写法

◆ 非递归写法

 ◆ 树的遍历

◆ 图的遍历 

3.BFS 广度优先

广度优先与深度优先不同，其从每一层下探访问节点，就好比是一滴水波纹逐渐向下扩散，然后扩散到每一层的节点上。

◆ 树的遍历 

◆ 代码写法

这里的队列其实就是我们常用到的列表。注意这里的 queue pop 是先进先出的，大家要和上面的 stack.pop 区分开。

4.DFS & BFS

我们可以根据上面的图再理解下 DFS 与 BFS 的遍历方式，如果都是用 List 实现的话，BFS 是 Deque 先进先出，DFS 则是 Stack 后进先出。

三.经典算法实战

1.Generate-Parentheses [22]

括号生成: https://leetcode.cn/problems/generate-parentheses/description/

◆ 题目分析

这里可以看做是一颗二叉树，其每个节点可以分叉为 '(' 和 ')'，我们需要遍历生成情况，并判断当前生成是否有效，再向下遍历。有效的条件有两个，一个是左括号一定是开头的第一个字符，另一个是左括号要和右括号数量一致。

◆ 广度优先

class Solution(object):
    def generateParenthesis(self, n):
        """
        :type n: int
        :rtype: List[str]
        """
        
        res = []

        def dfs(cur, left, right):
            # 终止条件
            if left == n and right == n:
                res.append(cur)
            
            # 左括号要在前面
            if left < n:
                bfs(cur + "(", left + 1, right)
            # 右括号要比左括号小
            if right < left:
                bfs(cur + ")", left, right + 1)
        
        dfs("", 0, 0)
        return res

 DFS 遍历的模版，直接一层一层下去找，直到满足 2n 的条件。

◆ 栈实现

class Solution(object):
    def generateParenthesis(self, n):
        """
        :type n: int
        :rtype: List[str]
        """
        
        res = []

        queue = [("", 0, 0)]

        while queue:
            cur, left, right = queue.pop(0)

            if left == right == n:
                res.append(cur)
            
            if left < n:
                queue.append((cur + "(", left + 1, right))
            if right < left:
                queue.append((cur + ")", left, right + 1))
        
        return res

DFS、BFS 的几种模版一定要多多练习，手到擒来。

◆ 二刷留念

class Solution(object):
    def generateParenthesis(self, n):
        """
        :type n: int
        :rtype: List[str]
        """
        # 保存结果
        result = []

        def generate(left, right, cur):
            # Stop
            if left == n and right == n:
                result.append(cur)

            if left < n:
                generate(left + 1, right, cur + "(")
            
            if right < left:
                generate(left, right + 1, cur + ")")

        generate(0, 0, "")

        return result

使用 DFS，不使用栈实现。 

2.Level-Order-Travesal [102]

二叉树层序遍历: https://leetcode.cn/problems/binary-tree-level-order-traversal

◆ 题目分析

二叉树 BFS 遍历，这里要求我们逐层按列表返回而不是一个列表全部返回，所以我们在 BFS 套模版的基础上，还需要记录其 level 层的位置。

◆ 广度优先

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:
            return []
        
        # 先进先出
        queue = [(0, root)]
        res = []

        while queue:
            # 记录对应的层次
            index, cur = queue.pop(0)

            if len(res) < index + 1:
                res.append([])
            res[index].append(cur.val)

            # 添加层消息与节点
            if cur.left:
                queue.append((index + 1, cur.left))
            if cur.right:
                queue.append((index + 1, cur.right))
            
        return res

按层遍历，每层下探时增加 index 找到其在 res 中对应的 list 保存即可。 

◆ 深度优先

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        res = []

        def dfs(root, level):
            if not root:
                return 

            if len(res) == level:
                res.append([])
            res[level].append(root.val)
            
            # 通过 level 存储层的信息
            if root.left:
                dfs(root.left, level + 1) 
            if root.right:
                dfs(root.right, level + 1)   
        
        dfs(root, 0)
        return res

层序遍历适合本题，但是深度遍历也可以实现，我们在向下探索的过程中可以获取当前的 level，只需将遍历到的结果对应的 level 找到即可。 

◆ 二刷留念

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:
            return []

        res = {}

        stack = [(root, 0)]

        while stack:
            node, level = stack.pop(0)
            if level not in res:
                res[level] = []
            res[level].append(node.val)

            if node.left:
                stack.append((node.left, level + 1))
            if node.right:
                stack.append((node.right, level + 1))

        return res.values()

3.Word-Ladder [127]

单词接龙: https://leetcode.cn/problems/word-ladder/description/

◆ 题目分析

层序遍历的方法，类似前面的基因突变，这里可以理解为连续突变且每次可以突变 26 个字母。

◆ 广度优先

class Solution(object):
    def ladderLength(self, beginWord, endWord, wordList):
        """
        :type beginWord: str
        :type endWord: str
        :type wordList: List[str]
        :rtype: int
        """
        # 去重使用
        valid_word = set(wordList)
        
        if endWord not in wordList or len(wordList) == 0:
            return 0
        
        queue = [(beginWord, 1)]

        while queue:

            new_queue = []

            for word, step in queue:
                # 停止条件
                if word == endWord:
                    return step
                
                # 处理当前元素
                for i in range(len(word)):
                    # 突变每一个位置
                    for char in 'abcdefghijklmnopqrstuvwxyz':
                        # 去重优化
                        if char != word[i]:
                            new_word = word[:i] + char + word[i + 1:] 
                            if new_word in valid_word:
                                valid_word.remove(new_word)
                                new_queue.append((new_word, step + 1))
            queue = new_queue
        return 0

这里 for char in 'abcd...' 可以使用 orc + chr 转换:

    for char in range(ord('a'), ord('z') + 1):
        print(chr(char))

◆ 双向 BFS

class Solution(object):
    def ladderLength(self, beginWord, endWord, wordList):
        """
        :type beginWord: str
        :type endWord: str
        :type wordList: List[str]
        :rtype: int
        """
        # 去重使用
        valid_word = set(wordList)
        
        if endWord not in wordList or len(wordList) == 0:
            return 0
        
        # 双向 BFS
        begin, end, step = {beginWord}, {endWord}, 1

        while begin and end:

            if len(begin) > len(end):
                begin, end = end, begin

            # 存储下一层
            next_level = set()
            for word in begin:
                for i in range(len(word)):
                    # a-z
                    for x in 'abcdefghijklmnopqrstuvwxyz':
                        # 节省无必要的替换
                        if x != word[i]:
                            new_word = word[:i] + x + word[i + 1:]

                            if new_word in end:
                                return step + 1
                            if new_word in valid_word:
                                next_level.add(new_word)
                                valid_word.remove(new_word)
            begin = next_level
            step += 1

        return 0

为了加快搜素速度我们改写为双向 BFS，Begin-A-B-C-D-End 我们拆分为 Begin -> B，End -> B，两边同时检索，最终输出总的 step。这里我们尝试了 ord 的写法，但是时间复杂度没有上面的直接。

4.Num-Of-Islands [200]

岛屿数量: https://leetcode.cn/problems/number-of-islands/description/

◆ 题目分析

对于每个点 row col，其都有上下左右 4 个分叉点，我们可以作为四叉树遍历，通过 generate_related_nodes 方法生成其不同分叉，并判断是否可以联通 [row,col] == 1，最后遍历所有 gird 的点，看可以走通多少次返回 count 即可。

◆ 深度优先

class Solution(object):
    def numIslands(self, grid):
        """
        :type grid: List[List[str]]
        :rtype: int
        """
        # 异常情况
        if not grid:
            return 0

        # 记录岛屿数量
        numLand = 0

        # 遍历并标记
        for row in range(len(grid)):
            for col in range(len(grid[0])):
                if grid[row][col] == "1":
                    self.dfs(row, col, grid)
                    numLand += 1
        
        return numLand
    
    # 在网格索引范围内
    def inArea(self, row, col, grid):
        return 0 <= row < len(grid) and 0 <= col < len(grid[0])
    
    def dfs(self, row, col, grid):
        # 判断节点合法性
        if not self.inArea(row, col, grid) or grid[row][col] != "1":
            return

        grid[row][col] = "2"

        self.dfs(row + 1, col, grid)
        self.dfs(row, col + 1, grid)
        self.dfs(row - 1, col, grid)
        self.dfs(row, col - 1, grid)

继续 dfs 的条件是在 grid 内且值为 "1"。 

5.Min-Gene-Mutation [433]

最小基因变化: https://leetcode.cn/problems/minimum-genetic-mutation/

◆ 题目分析

题目给定了基因的 4 种类型 'ACGT'，就像是 4 叉树一样，我们每次遍历有 4 个方向可以走，当前层遍历完再向下一个索引继续遍历，总共有 4^^8 种情况，由于有 bank 的限制，我们可以过滤掉多种情况。 

◆ 广度优先

class Solution(object):
    def minMutation(self, startGene, endGene, bank):
        """
        :type startGene: str
        :type endGene: str
        :type bank: List[str]
        :rtype: int
        """

        # 没有基因库或最终突变不在基因库
        if not bank or endGene not in bank:
            return -1

        queue = []
        queue.append((startGene, 0))
        # 记录基因是否有效
        valid_bank = set(bank)

        while queue:
            # 获取当前步数
            gene, step = queue.pop(0)

            # 突变每一个位置
            for i in range(len(gene)):
                for g in 'ACGT':
                    # 从第一个位置开始，每个突变一次
                    if g != gene[i]:
                        change_gene = gene[:i] + g + gene[i + 1:]
                        if change_gene == endGene:
                            return step + 1
                        elif change_gene in valid_bank:
                            queue.append((change_gene, step + 1))
                            valid_bank.remove(change_gene)

        return -1

 判断 g != gene[i] 减少相同字符的替换。

6.Largest-Values [515]

每层的最大值: https://leetcode.cn/problems/find-largest-value-in-each-tree-row/

◆ 题目分析

层序遍历，找到每一层的最大值即可，也可以深度遍历，记录即可。

◆ 广度优先

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def largestValues(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        
        if not root:
            return []

        queue = [root]
        res = []

        while queue:
            cur_max = -99999999999
            new_queue = []
            # 遍历每一层
            for i in range(len(queue)):
                if queue[i]:
                    cur_max = max(cur_max, queue[i].val)
                    if queue[i].left:
                        new_queue.append(queue[i].left)
                    if queue[i].right:
                        new_queue.append(queue[i].right)
            res.append(cur_max)
            queue = new_queue
        
        return res

空间复杂度主要使用了 queue，其余操作主要在计算 max。 

◆ 深度优先

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def largestValues(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        
        res = []

        def dfs(root, level):
            # 停止条件
            if not root:
                return
            
            # 当前层逻辑
            if len(res) == level:
                res.append(-9999999999)
            res[level] = max(res[level], root.val)

            # 下一层
            if root.left:
                dfs(root.left, level + 1)
            if root.right:
                dfs(root.right, level + 1)
        
        dfs(root, 0)
        return res

同理，DFS 时可以使用 level 保存层的信息，我们通过 level 与数组建立关系构造 max 即可。

7.Mine-Clearance [529]

扫雷游戏: https://leetcode.cn/problems/minesweeper/description/ 

◆ 题目分析

给定初始二维数组和起点，返回修改后的二维数组。若起点处是雷，即 ‘M’，直接将其修改为 'X'，游戏结束；若起点处是空，即 ‘E’，则从起点开始向 8 邻域中的空地搜索，直到到达邻接💥的空地停止。和二叉树从根结点开始搜索，直到达到叶子节点停止，是几乎一样的，可以使用 BFS/DFS，但是 BFS 需要记录重复的节点。

◆ 深度优先 

class Solution(object):

    dx = [1, 1, -1, -1, 1, -1, 0, 0]
    dy = [1, -1, 1, -1, 0, 0, 1, -1]

    def updateBoard(self, board, click):
        """
        :type board: List[List[str]]
        :type click: List[int]
        :rtype: List[List[str]]
        """

        # 空盘
        if not board:
            return []
        # 空点
        if not click:
            return board

        # 点击位置
        row = click[0]
        col = click[1]

        # 💥
        if board[row][col] == "M":
            board[row][col] = "X"
        else:
            # DFS
            self.dfs(row, col ,board)
        
        return board

    def dfs(self, row, col, board):

        if not self.inArea(row, col, board):
            return

        # 周围是否有雷
        count = 0
        for i in range(8):
            x = row + self.dx[i]
            y = col + self.dy[i]

            if self.inArea(x, y, board) and board[x][y] == "M":
                count += 1
        
        if count > 0:
            board[row][col] = str(count)
            return 
        
        # 周围没雷标记为 B
        board[row][col] = 'B'
        for i in range(8):
            x = row + self.dx[i]
            y = col + self.dy[i]

            if self.inArea(x, y, board) and board[x][y] == "E":
                self.dfs(x, y, board)

    
    def inArea(self, row, col, board):
        return 0 <= row < len(board) and 0 <= col < len(board[0])

再套一下 DFS 的模版:

终止条件 - 当前 row/col 周围存在雷即 'M'

处理逻辑 - 有雷更新 cnt、没雷标记为 'B'

下探逻辑 - 上下左右撇那八个点进行多叉寻找

四.总结

虽然 BFS、DFS 的模版很简单，但是怎么和实际的题目联系在一起还需要多多实践，多多练习，上面一些题目是为了 BFS、DFS 而 BFS、DFS 实际上更有效率更优的算法，大家也可以到官网参考题解，更进一步。

BIT_666
关注
  • 48
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
python 深度优先搜索DFS和广度优先搜索BFS
m0_59553037的博客
03-03 497
BFS是连通图的一种遍历策略，沿着树(图)的宽度遍历树(图)的节点，最短路径算法可以采用这种策略，在二叉树中体现为一层一层的搜索，也就是层序遍历。通过弹栈来回溯到上一个节点。
二叉树遍历BFS与DFS详细代码python版
01-18
二叉树遍历BFS与DFS详细代码python版
Python宽搜（BFS）和深搜（DFS）
gy的博客
02-17 4995
目录BFSBFS是什么BPS工作过程和原理BFS应用场景python实现BFS（树和图）python实现BFS图python实现图的最短路径python实现BFS树DFSDFS是什么DFS工作过程和原理DFS应用场景python实现DFSpython实现DFS图python实现DFS树何时使用深搜和广搜python实现树前中后序遍历前序遍历中序遍历后序遍历参考资料 BFS BFS是什么 BFS称为宽度优先搜索也叫做广度优先搜索，其别名又叫BFS，属于一种盲目搜寻法。 Dijkstra单源最短路径算法和Pri
利用Python实现BFS和DFS
zjjaibc的博客
06-03 4655
BFS ：广度优先一层一层搜，注意先后的顺序。(DE顺序不能换！)结论会不唯一。DFS:深度优先“一条路走到黑”：队列实现BFS：用栈实现DFS: 保证每次取的时候，取的都是他的邻接点。 ​​​​​​​ ​​​​​​​ ​​​​​​​ 从A开始，压入stack内，在pop出，再放入A的邻接点CB （顺序可交换） 再pop B再放入B的邻接点D （C已经再栈中了） 再pop D再放入D的邻接点E和F （以F在栈顶为例） 再pop
Python BFS和DFS算法
qq_43540763的博客
03-23 8372
Python BFS和DFS算法 看了b站灯神的视频，整理如下。最后再加上几条实战题。 1.BFS bfs全称是广度优先搜索，任选一个点作为起始点，然后选择和其直接相连的（按顺序展开）走下去。主要用队列实现，直接上图。两个搜索算法都只需要把图全都遍历下来就好。 具体实现时：用字典来表示图；队列直接用python里的列表就好 python代码： graph={ "A":["B","C"], "B":["A","C","D"], "C":["A","B","D","E"], "
BFS算法 （python)
cindera的刷题记录
03-06 8044
广度优先搜索（也称宽度优先搜索，缩写BFS，以下采用广度来描述）是连通图的一种遍历策略。因为它的思想是从一个顶点V0开始，辐射状地优先遍历其周围较广的区域，故得名。 也就是我们在数据结构中学习过的BFS算法。按层数的遍历。 同上图所示，我们从A开始得到它的一个BFS就是ABCDEF。我们使用代码实现该程序。 grap = { "A":["B","C"], "B":["A","C","D"], "C":["A","B","D","E"], "D":["B","C".
数据结构与算法 Python语言描述-裘宗燕
10-01
《数据结构与算法 Python语言描述》是裘宗燕教授撰写的一本专著，主要面向希望深入理解数据结构和算法，并且希望通过Python语言实现这些概念的读者。这本书是北京大学的教学资源，因其深入浅出的讲解方式而备受推崇...
用python学习数据结构与算法 教程
02-02
在本教程中，我们将深入探讨如何使用Python语言学习数据结构与算法，这是一门对于任何计算机科学或软件工程领域的专业人士至关重要的学科。Python因其简洁易读的语法而成为初学者和专家的首选语言，它提供了丰富的库...
数据结构与算法-课件-代码-Python语言描述
10-23
在这个“数据结构与算法-课件-代码-Python语言描述”的压缩包中，包含了丰富的教学资源，旨在帮助学习者深入理解这些核心概念。 首先，数据结构是存储和组织数据的方式，它决定了数据的访问效率和处理速度。在...
Python-Python中数据结构和算法的介绍
08-10
在Python编程语言中，数据结构和算法是两个非常核心的概念，它们对于编写高效、可维护的代码至关重要。数据结构是组织、存储和处理数据的方式，而算法是解决问题或执行任务的明确步骤。在这个主题中，我们将深入探讨...
算法之BFS与DFS
10-19
**算法之BFS（广度优先搜索）与DFS（深度优先搜索）** 在计算机科学中，图论和算法是至关重要的部分，而BFS（广度优先搜索）和DFS（深度优先搜索）是两种最基础且广泛使用的图遍历算法。它们在解决各种问题时起到...
Python算法：BFS
qq_65144447的博客
02-16 926
BFS搜索的原理：“逐层扩散”。从起点出发，按层次从近到远，逐层先后搜索。 编码：用队列实现。 应用：BFS一般用于求最短路径问题，BFS的特点是逐层搜索，先搜到的层离起点更近。
Python实现BFS和DFS搜索算法
weixin_46390192的博客
11-11 509
Python实现BFS和DFS搜索算法
python实现DFS和BFS整理
January001的博客
11-25 1153
BFS是广度遍历，也就是一层一层扩展开的查找，先把第一层的找完，再找第二层，然后找第三层...使用到的数据结构是队列，先访问第一个节点，然后访问它的所有邻接点，然后访问邻接点的邻接点，在此过程中，要保证访问过的点不重复访问。 DFS是深度遍历，从一个点开始，逐渐沿着一条路径向下查找，查找到尽头的时候，回溯到上一个节点，再继续查找...使用的数据结构是栈，访问的下一个节点是当前节点的一个邻接点，然...
Python 算法基础篇：深度优先搜索（ DFS ）和广度优先搜索（ BFS ）
小蓝枣的博客
07-19 7202
深度优先搜索（ DFS ）和广度优先搜索（ BFS ）是两种常用的图遍历算法，用于在图中搜索目标节点或遍历图的所有节点。本篇博客将介绍 DFS 和 BFS 算法的基本概念，并通过实例代码演示它们的应用。
Python 实现 BFS 和 DFS
Harrytsz的博客
11-18 2464
# BFS graph = { &amp;quot;A&amp;quot; : [&amp;quot;B&amp;quot;, &amp;quot;C&amp;quot;], &amp;quot;B&amp;quot; : [&amp;quot;A&amp;quot;, &amp;quot;C&amp;quot;, &amp;quot;D&amp;quot;], &
《Redis篇：》《Redis持久化、主从、哨兵、集群、常见问题重点回顾》
qq_39773004的博客
11-03 323
1.Redis的持久化： RDB（默认） 二进制存储持久化数据，速度相对较快 持久化时机：save second keys RDB无法保证数据的安全 2.AOF AOF是一日志的形式持久化，用户的写操作，速度慢 AOF持久化时机：always ，everysec，no AOF相对RDB更加安全 3.官方推荐同时开启RDB和AOF两种持久化机制 在恢复数据时，AOF的持久化优先级更高 同时开启AOF和RDB ，在RDB执行持久化时，RDB数据会被AOF覆盖 4.AOF重写 自动重写：指定AOF的文件超过
【Python搜索算法】广度优先搜索（BFS）算法原理详解与应用，示例+代码
最新发布
qq_35831906的博客
10-16 7530
广度优先搜索（Breadth-First Search，BFS）是一种图遍历算法，用于系统地遍历或搜索图（或树）中的所有节点。BFS的核心思想是从起始节点开始，首先访问其所有相邻节点，然后逐层向外扩展，逐一访问相邻节点的相邻节点，以此类推。这意味着BFS会优先探索距离起始节点最近的节点，然后再逐渐扩展到距离更远的节点。BFS通常用于查找最短路径、解决迷宫问题、检测图是否连通以及广泛的图问题。BFS算法的步骤如下：初始化：选择一个起始节点，将其标记为已访问，并将其放入队列中（作为起始节点）。
python bfs&dfs
h_666666的博客
07-21 213
#coding=utf-8 from multiprocessing import Queue #from queue import queue adj_list = { "A":["B","D"], "B":["A","C"], "C":["B"], "D":["A","E","F"], "E":["D","F","G"], "F":["D","E","H"], "G":["E","H"], "H":["G","F"] } print (adj_list) visited= {}.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

BIT_666

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值