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

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

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

1.广度优先搜索 Breath-First-Search

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

算法原理

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

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

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

将上图整理得下图

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

算法实现

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的最短路径：

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算法寻找栅格地图中两点之间的最短路径的代码实现如下：

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

2.深度优先搜索 Depth-First-Search

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

算法原理

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

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

算法实现

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的最短路径：

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寻找最短路径。