深入浅出广度优先搜索(BFS):从原理到 Python 代码实现

引言

在图论和计算机科学中,广度优先搜索(Breadth - First Search,简称 BFS)是一种用于遍历或搜索图或树结构的算法。它从给定的起始节点开始,以广度优先的方式逐层探索图的节点,直到找到目标节点或遍历完整个图。BFS 在许多实际问题中都有广泛应用,如路径规划、迷宫求解、社交网络分析等。本文将详细介绍 BFS 的原理,并通过一个 Python 代码示例,即使用 BFS 查找二维网格中从起点到终点的最短路径,来深入理解 BFS 的实现过程。

广度优先搜索原理

核心思想

BFS 的核心思想是从起始节点开始,首先访问与其直接相连的所有节点(即第一层节点),然后再依次访问第一层节点的所有未访问过的邻居节点(即第二层节点),以此类推,像波浪一样逐层向外扩展,直到找到目标节点或遍历完所有可达节点。

数据结构支持

为了实现 BFS,我们通常使用队列(Queue)这种数据结构。队列具有先进先出(FIFO)的特性,正好符合 BFS 逐层扩展的顺序。在 BFS 过程中,我们将起始节点放入队列,然后不断从队列中取出节点进行访问,并将其未访问过的邻居节点加入队列,这样就可以保证按照层次顺序进行遍历。

图示说明

假设我们有一个简单的图结构如下:

从节点 A 开始进行 BFS,首先将 A 放入队列。然后取出 A,访问 A,并将其邻居 B、C、D 加入队列。此时队列中元素为 [B, C, D]。接着取出 B,访问 B,并将其邻居 E 加入队列,队列变为 [C, D, E]。再取出 C,访问 C,其邻居 F 加入队列,队列变为 [D, E, F]。以此类推,直到队列为空或者找到目标节点。通过这种方式,我们可以按照层次顺序遍历整个图。

Python 代码实现最短路径查找(后续有完整代码)

def bfs_shortest_path(grid, start, end):
    """
    使用广度优先搜索(BFS)查找从起点到终点的最短路径。
    
    :param grid: 二维列表表示的地图,1代表可通过的格子,0代表障碍物。
    :param start: 起点坐标 (x, y)。
    :param end: 终点坐标 (x, y)。
    :return: 如果存在路径则返回最短距离,否则返回 -1。
    """
    n, m = len(grid), len(grid[0])
    directions = [(1, 0), (-1, 0), (0, 1), (0, -1)]
    queue = [(start[0] - 1, start[1] - 1, 0)]  # 初始化队列,包含起点及初始距离

    while queue:
        x, y, distance = queue.pop(0)
        
        # 检查是否到达终点
        if x == end[0] - 1 and y == end[1] - 1:
            return distance
        
        # 探索四个方向
        for dx, dy in directions:
            nx, ny = x + dx, y + dy
            
            # 检查新位置是否在网格内且可通过
            if 0 <= nx < n and 0 <= ny < m and grid[nx][ny]:
                # 标记为已访问,并加入队列
                grid[nx][ny] = 0
                queue.append((nx, ny, distance + 1))
    
    return -1  # 如果没有找到路径

1、初始化部分

(1)获取网格的行数 n 和列数 m

(2)定义四个方向的偏移量 directions,分别表示向右、向左、向下、向上移动。

(3)将起点坐标进行调整(因为题目中坐标从 1 开始,而代码中索引从 0 开始),并将其与初始距离 0 一起放入队列 queue

2、BFS 循环部分

(1)使用 while 循环,只要队列不为空,就从队列中取出一个节点 (x, y, distance),其中 x 和 y 是当前节点的坐标,distance 是从起点到当前节点的距离。

(2)检查当前节点是否为终点,如果是,则返回当前距离,即找到了最短路径。

(3)遍历四个方向,计算新的坐标 nx 和 ny.

(4)检查新坐标是否在网格范围内且对应网格值为 1(表示可通过)。如果满足条件,则将该位置标记为已访问(设为 0),并将新节点 (nx, ny, distance + 1) 加入队列,这里距离加 1 是因为从当前节点移动到新节点。

3、返回结果:如果循环结束后仍未找到路径,则返回 -1。

输入处理部分

# 输入处理
if __name__ == "__main__":
    import sys
    input = sys.stdin.read
    data = input().split()
    
    n, m = map(int, data[:2])
    grid = [list(map(int, data[i:i + m])) for i in range(2, 2 + n * m, m)]
    start_end = list(map(int, data[2 + n * m:]))
    start, end = start_end[:2], start_end[2:]
    
    print(bfs_shortest_path(grid, start, end))

这段代码用于处理输入数据。首先从标准输入读取所有数据并分割成字符串列表 data。然后从 data 中提取网格的行数 n 和列数 m,接着构建二维网格 grid。最后提取起点和终点坐标,并调用 bfs_shortest_path 函数计算最短路径并输出结果。

可视化示例

假设我们有一个简单的 5x5 网格如下:

设起点为 (1, 1),终点为 (5, 5)。BFS 的过程如下:

1、初始时,队列中只有起点 (0, 0, 0)

2、取出起点 (0, 0),访问它,将其可通过的邻居 (0, 1) 和 (1, 0) 加入队列,此时队列变为 [(0, 1, 1), (1, 0, 1)]

3、取出 (0, 1),访问它,将其可通过的邻居 (0, 2) 加入队列,队列变为 [(1, 0, 1), (0, 2, 2)]

4、以此类推,随着 BFS 的进行,队列不断更新,节点按照层次顺序被访问,直到找到终点 (4, 4),最终返回最短路径的距离。

完整代码

def bfs_shortest_path(grid, start, end):
    """
    使用广度优先搜索(BFS)查找从起点到终点的最短路径。
    
    :param grid: 二维列表表示的地图,1代表可通过的格子,0代表障碍物。
    :param start: 起点坐标 (x, y)。
    :param end: 终点坐标 (x, y)。
    :return: 如果存在路径则返回最短距离,否则返回 -1。
    """
    n, m = len(grid), len(grid[0])
    directions = [(1, 0), (-1, 0), (0, 1), (0, -1)]
    queue = [(start[0] - 1, start[1] - 1, 0)]  # 初始化队列,包含起点及初始距离

    while queue:
        x, y, distance = queue.pop(0)
        
        # 检查是否到达终点
        if x == end[0] - 1 and y == end[1] - 1:
            return distance
        
        # 探索四个方向
        for dx, dy in directions:
            nx, ny = x + dx, y + dy
            
            # 检查新位置是否在网格内且可通过
            if 0 <= nx < n and 0 <= ny < m and grid[nx][ny]:
                # 标记为已访问,并加入队列
                grid[nx][ny] = 0
                queue.append((nx, ny, distance + 1))
    
    return -1  # 如果没有找到路径


# 输入处理
if __name__ == "__main__":
    import sys
    input = sys.stdin.read
    data = input().split()
    
    n, m = map(int, data[:2])
    grid = [list(map(int, data[i:i + m])) for i in range(2, 2 + n * m, m)]
    start_end = list(map(int, data[2 + n * m:]))
    start, end = start_end[:2], start_end[2:]
    
    print(bfs_shortest_path(grid, start, end))

总结

广度优先搜索是一种强大且常用的图遍历算法,通过使用队列实现层次化的节点探索,能够有效地找到从起始节点到目标节点的最短路径(在无权图中)。通过上述代码示例和详细分析,希望读者能对 BFS 的原理和实现有更深入的理解,并能够在实际问题中灵活应用 BFS 解决相关问题。

希望这篇博客能帮助你更好地理解广度优先搜索算法及其在 Python 中的应用。如果你对 BFS 还有其他疑问或者有不同的见解,欢迎在评论区留言讨论。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值