图论算法----BFS走二维迷宫

BFS原理

代码实现

import numpy as np
import random


class BFS:
    def __init__(self, row, column, start_node, end_node):
        self.row = row                # 迷宫尺寸：行
        self.column = column          # 迷宫尺寸：列
        self.start_node = start_node  # 起点
        self.end_node = end_node      # 终点
        self.maze = self.make_01maze()

    def make_01maze(self):  # 制作01迷宫
        maze = np.zeros(shape=(self.row, self.column))
        random.seed(5)
        for r in range(self.row):
            for c in range(self.column):
                if (r, c) != (0, 0) and (r, c) != (self.row - 1, self.column - 1):
                    maze[r, c] = random.randint(0, 1)
        print('迷宫：\n', maze)
        return maze

    def generate_adjacent_graph(self, mr, mc, temp_list, current_node):  # 生成当前节点的邻近节点
        row, column = self.maze.shape
        if self.maze[mr, mc] == 1:
            return []
        else:
            if mr != 0:
                temp_list.append(current_node - column)
            if mr != row - 1:
                temp_list.append(current_node + column)
            if mc != 0:
                temp_list.append(current_node - 1)
            if mc != column - 1:
                temp_list.append(current_node + 1)
            return temp_list

    def bfs(self):  # 广度优先算法
        row, column = self.maze.shape
        last_node = np.ones(row * column) * -1  # 记录所有节点的 上一个节点

        queue = [self.start_node]  # 初始化队列并将起始节点加入队列
        while queue:  # 只要队列不为空，就一直循环
            current_node = queue.pop(0)  # 从队列中取出一个节点
            mr, mc = int(current_node / column), int(current_node % column)  # 计算当前节点在二维迷宫数组中的坐标
            adjacent_graph = self.generate_adjacent_graph(mr, mc, [], current_node)
            for node in adjacent_graph:  # 遍历当前节点的所有邻近节点
                if last_node[node] == -1:  # 判断邻近节点是否被记录过 / 判断邻近节点是否有上一个节点
                    queue.append(node)  # 该邻近节点没有被记录过，则加入队列
                    last_node[node] = current_node  # 并记录当前节点作为其临近节点的上一个节点
        return last_node

    def print_path(self, last_node):  # 输出其中一条最优路径
        if last_node[self.end_node] == -1:
            print('节点{} -> 节点{} 是不可达的!')
        else:
            save_path = [self.end_node]
            current_node = self.end_node
            while True:
                if current_node == self.start_node:
                    break
                save_path.append(int(last_node[current_node]))
                current_node = int(last_node[current_node])

            print('节点{} -> 节点{} 的最短路径为：'.format(self.start_node, self.end_node))
            for node in save_path[::-1]:
                if node != self.end_node:
                    print('node_{}'.format(node), end=' -> ')
                else:
                    print('node_{}'.format(node))


def main():
    row, column = 6, 6
    bfs = BFS(row, column, start_node=0, end_node=row*column - 1)
    last_node = bfs.bfs()
    bfs.print_path(last_node)


if __name__ == '__main__':
    main()

输出结果