路径规划——广度优先搜索与深度优先搜索

路径规划------广度优先搜索与深度优先搜索

https://www.hello-algo.com/chapter_graph/graph_traversal/

在图论中也称为广度优先遍历,类似于树的层序遍历。

算法原理

从起始节点出发,首先访问它的邻近节点,然后依次访问这些邻近节点的邻近节点,直到所有节点都被访问到。广度优先搜索是从一个起始节点开始逐层地访问所有节点的。

广度优先搜索是一种图遍历算法,每向前走一步可能访问一批顶点,不像深度优先搜索那样有回退的情况,因此它不是一个递归的算法。为了实现逐层的访问,算法必须借助一个辅助队列,以记忆正在访问的顶点的下一层顶点。

现有如下节点图Graph,要求从A点开始搜索,搜索全部节点,将节点搜索序列作为结果输出。

将上图整理得下图

那么整个广度优先搜索的过程如下图:

算法实现

python 复制代码
from collections import deque

def bfs(graph, start):
    # 初始化队列,并将起始节点加入队列
    queue = deque([start])
    # 初始化访问顺序列表
    visited = [start]

    while queue:
        # 取出队列中的当前节点
        current = queue.popleft()
        
        # 遍历当前节点的所有邻居节点
        for neighbor in graph[current]:
            if neighbor not in visited:  # 如果邻居节点尚未被访问
                # 将邻居节点加入队列
                queue.append(neighbor)
                # 记录访问顺序
                visited.append(neighbor)

    return visited

# 示例图的定义
graph = {
    'A': ['B', 'C'],
    'B': ['A', 'D', 'E'],
    'C': ['A', 'F'],
    'D': ['B'],
    'E': ['B', 'F'],
    'F': ['C', 'E']
}

# 使用BFS算法
start_node = 'A'
visited = bfs(graph, start_node)
print(f"Visit order: {visited}")

寻找在上图中A->E的最短路径:

python 复制代码
from collections import deque

def bfs(graph, start, goal):
    # 初始化队列,并将起始节点加入队列
    queue = deque([start])
    # 初始化访问顺序列表
    visited = [start]
    # 初始化父节点集合
    previous = {start: None}

    while queue:
        # 取出队列中的当前节点
        current = queue.popleft()

        if current == goal:
            break
        
        # 遍历当前节点的所有邻居节点
        for neighbor in graph[current]:
            if neighbor not in visited:  # 如果邻居节点尚未被访问
                # 将邻居节点加入队列
                queue.append(neighbor)
                # 记录访问顺序
                visited.append(neighbor)
                # 将当前节点保存为邻节点的父节点
                previous[neighbor] = current

    path = []
    current = goal
    # Find the full path by backtracking
    while current is not None:
        path.append(current)
        current = previous.get(current)
    path = path[::-1]
    distance = len(path)-1

    return path,distance

# 示例图的定义
graph = {
    'A': ['B', 'C'],
    'B': ['A', 'D', 'E'],
    'C': ['A', 'F'],
    'D': ['B'],
    'E': ['B', 'F'],
    'F': ['C', 'E']
}

# 使用BFS算法
start = 'A'
goal = 'E'
path,distance = bfs(graph, start, goal)
print("Distance: ",distance)
print(f"Short path: {path}")

输出结果:

利用BFS算法寻找栅格地图中两点之间的最短路径的代码实现如下:

python 复制代码
from collections import deque
import numpy as np

class BFS:
    def __init__(self, grid, board_size, start, goal):
        self.grid = grid
        self.board_size = board_size
        self.start = start
        self.goal = goal

    def plan(self):
        """
            Use BFS algorithm to plan path in grid map.
            Since the cost between every two neighbouring nodes is 1 which is different from Dijkstra,
            only four directions including up, right, down, left are allowed
        
        """

        visited = set() # Used to mark nodes that are visited
        self.searched = [] # Used to record nodes that are searched

        previous_nodes = {self.start: None}

        que = deque([self.start])

        visited.add(self.start)

        while que:
            # Select the node closest to the start node
            current_node = que.popleft()

            # Append the current node into searched nodes
            self.searched.append(current_node)
            
            # Break when the current node is the goal
            if current_node == self.goal:
                break
            
            # Find the neighbors of the current node and determine in turn if they have already been visited
            neighbors = self.get_neighbors(current_node)
            for neighbor in neighbors:
                # If the current node has been visited, skip it
                if neighbor in visited:
                    continue

                previous_nodes[neighbor] = current_node
                que.append(neighbor)
                visited.add(neighbor) # mark the neighbor is visited
        
        self.path = []
        current_node = self.goal
        # Find the full path by backtracking
        while current_node is not None:
            self.path.append(current_node)
            current_node = previous_nodes.get(current_node)
        self.path = self.path[::-1]

        return len(self.path)-1


    def get_neighbors(self, node):
        neighbors = []
        next_directions = [(1,0),(0,-1),(-1,0),(0,1)]

        for next_d in next_directions:
            neighbor = (node[0] + next_d[0], node[1] + next_d[1])
            if self.board_size <= neighbor[0] < len(self.grid)-self.board_size and self.board_size <= neighbor[1] < len(self.grid[0])-self.board_size:
                if self.grid[neighbor[0]][neighbor[1]] == 0:
                    neighbors.append(neighbor)

        return neighbors

在树和图论的数据结构中也称为深度优先遍历。

算法原理

从起始节点出发,沿着一个分支深入到尽可能深的节点,然后回溯并继续访问其他分支。这种"走到尽头再返回"的算法范式通常是基于递归来实现的。

同样以上述例子为例,整个深度优先搜索的过程如下:

算法实现

Python 复制代码
from collections import deque

def dfs(graph, current_node, visited):

    visited.append(current_node)
    
    # 遍历当前节点的所有邻居节点
    for neighbor in graph[current_node]:
        if neighbor in visited:  # 如果邻居节点已被访问则跳过
            continue
        dfs(graph, neighbor, visited)

    return visited

# 示例图的定义
graph = {
    'A': ['B', 'C'],
    'B': ['A', 'D', 'E'],
    'C': ['A', 'F'],
    'D': ['B'],
    'E': ['B', 'F'],
    'F': ['C', 'E']
}

# 使用DFS算法
start_node = 'A'
visited = dfs(graph, start_node, [])
print(f"Visit order: {visited}")

寻找在上图中A->E的最短路径:

python 复制代码
from collections import deque

def dfs(graph, current_node, goal, path, shortest_path, distance):

    path.append(current_node)
    
    if current_node == goal:
        if len(path)-1<distance:
            shortest_path[:] = path
            distance = len(shortest_path)-1
        path.pop()
        return shortest_path, distance
    
    # 遍历当前节点的所有邻居节点
    for neighbor in graph[current_node]:
        if neighbor in path:  # 如果邻居节点已被访问则跳过
            continue

        shortest_path, distance = dfs(graph, neighbor, goal, path, shortest_path, distance)
    
    path.pop()

    return shortest_path, distance


# 示例图的定义
graph = {
    'A': ['B', 'C'],
    'B': ['A', 'D', 'E'],
    'C': ['A', 'F'],
    'D': ['B'],
    'E': ['B', 'F'],
    'F': ['C', 'E']
}

# 使用DFS算法
start_node = 'A'
goal = 'F'
path = []
distance = float('inf')
shortest_path, distance = dfs(graph, start_node, goal, path, [], distance)
print("Distance: ",distance)
print(f"Short path: {shortest_path}")

输出结果:

虽然DFS可以找到最短路径,但是需要找到所有的路径之后才能知道最短路径,所有非常耗时,例如在上述BFS中的栅格地图中寻找起点到终点的最短路径是非常困难的,尽管也可以找到最短路径但是非常耗时,所以一般不会使用DFS寻找最短路径。

相关推荐
vir021 天前
好奇怪的游戏(BFS)
数据结构·c++·算法·游戏·深度优先·图论·宽度优先
是糖不是唐1 天前
代码随想录算法训练营第五十二天|Day52 图论
c语言·算法·深度优先·动态规划·图论
爱吃喵的鲤鱼2 天前
高阶数据结构——图
数据结构·c++·算法·图搜索
是糖不是唐2 天前
代码随想录算法训练营第五十一天|Day51 图论
c语言·数据结构·算法·深度优先·图论
Shiroha Wang3 天前
【数据结构OJ】【图论】红色警报
数据结构·笔记·算法·深度优先·图论
kitesxian4 天前
Leetcode236.二叉树的最近公共祖先(HOT100)
算法·深度优先
笨小古4 天前
路径规划——RRT*算法
算法·路径规划·导航
攻城丶狮4 天前
信息学奥赛-一本通-第二部分 基础算法 --> 第五章 搜索与回溯算法
c++·算法·青少年编程·深度优先·图论
Knight8404 天前
数据结构王道P234第二题
数据结构·c++·算法·深度优先·图论
席万里6 天前
二叉树Golang
开发语言·golang·深度优先