day20 Python 實現的廣度優先搜索實現迷宮算法

 

# 使用 Python 實現的廣度優先搜索實現迷宮算法

class Maze(object):

    def __init__(self, maze, start, end):

        self.maze = maze
        self.start = start
        self.end = end
        self.direction = [[-1, 0], [0, -1], [1, 0], [0, 1]]  # 移動方向順序: 上左下右

    def move(self, x, y):
        """
        執行迷宮的上下左右操作
        :param x: 起始坐標
        :param y: 移動的方向
        :return: 新的坐標
        """

        return [x[0] + y[0], x[1] + y[1]]

    def at(self, grid, x):
        """
        傳入一個maze和坐標，判斷坐標是否越界，如果沒有越界根據坐標返回對應maze中的數值
        :param grid: maze
        :param x: 查找坐標
        :return: maze中的數值和狀態
        """
        # 判斷row 是否越界
        if x[0] < 0 or x[0] >= len(grid):
            return 0, False
        # 判斷col 是否越界
        if x[1] < 0 or x[1] >= len(grid[0]):
            return 0, False

        return grid[x[0]][x[1]], True

    def walk(self):
        """
        創建一個新的二維數組，self.maze每走一步，就在這個新的二維數組對應位置上記錄行走的步數
        :return: 記錄了行走步數的二維數組
        """
        # 創建一個大小和self.maze一樣大小的二維數組，此二維數組中所有的值初始化為0，用來記錄行走的步數
        steps = [[i * 0 for i in range(len(self.maze[0]))] for j in range(len(self.maze))]

        Q = [self.start]

        while len(Q) > 0:
            index = Q[0]
            # 找到出口
            if index == self.end:
                break

            Q = Q[1:]

            for d in self.direction:
                next = self.move(index, d)

                val, ok = self.at(self.maze, next)

                # 越界或者撞牆，跳過
                if not ok or val == 1:
                    continue

                # 新的二維數組中移動的下一個點如果值不是0的話，說明已經走過這個點，直接跳過
                val, ok = self.at(steps, next)
                if not ok or val != 0:
                    continue

                # 回到原點
                if next == self.start:
                    continue

                # 將steps中每走一步，記錄當前的步數
                val, ok = self.at(steps, index)
                if ok:
                    steps[next[0]][next[1]] = val + 1

                # 每走一步，將此時的位置加入到隊列中
                Q.append(next)

        return steps

    def path(self, grid):
        """
        根據steps計算最優路徑
        :param grid: steps迷宮圖
        :return: 存放路徑的列表
        """
        last = grid[len(maze) - 1][len(maze[0]) - 1]
        lookup_path = [[len(maze) - 1, len(maze[0]) - 1], ]

        while last > 0:
            last -= 1
            index = lookup_path[-1]

            for d in self.direction:
                next = self.move(index, d)

                val, err = self.at(grid, next)
                if val == last:
                    lookup_path.append(next)
                    break

        return lookup_path


if __name__ == '__main__':

    # maze = [[0, 0, 1, 0, 1], [1, 0, 0, 0, 1], [0, 0, 1, 1, 0], [0, 1, 0, 0, 0], [0, 0, 0, 1, 0]]
    maze = [[0, 1, 0, 0, 0], [0, 0, 0, 1, 0], [0, 1, 0, 1, 0], [1, 1, 1, 0, 0], [0, 1, 0, 0, 1], [0, 1, 0, 0, 0]]

    # 打印二維數組
    print("原始迷宮圖:")
    for k in maze:
        for v in k:
            print("%2d" % v, end=" ")
        print("")

    print("\n")

    print("行走路線圖:")
    step = Maze(maze, [0, 0], [len(maze) - 1, len(maze[0]) - 1])
    steps = step.walk()

    for k in steps:
        for v in k:
            print("%2d" % v, end=" ")
        print("")

    print("\n")

    print("走出迷宮共需要%s步\n" % steps[len(maze) - 1][len(maze[0]) - 1])

    # 計算最優路徑
    path = step.path(steps)
    path.reverse()
    print("最優路徑是: ", path)