队列-迷宫问题

给一个二维列表，表示迷宫（0表示通道，1表示围墙）。给出一条走出迷宫的路径

队列-广度优先搜索，使用队列存储当前正在考虑的节点（仅存储当前节点），从一个节点开始，寻找所有接下来能继续走的点，继续不断寻找直到找到出口

难点：这里用一个新的列表path存储了出队的元素，并在queue中用第三个位置记录了每个节点的上一个节点的下标，即当前节点是由哪个节点过来的

# 广度优先搜索
from collections import deque

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

dirs = [
    lambda x,y:(x+1,y),
    lambda x,y:(x-1,y),
    lambda x,y:(x,y-1),
    lambda x,y:(x,y+1)
]　　# 每到一个点都有四个方向

def print_r(path):　　# 输出路径
    curNode = path[-1]
    realpath = []
    while curNode[2] != -1:  # 如果不是 起点 就一直循环
        realpath.append(curNode[0:2])
        curNode = path[curNode[2]] # curNode[2]是上一个节点的下标值

    realpath.append(curNode[0:2])  # 把 起点 放进去
    realpath.reverse()
    for node in realpath:
        print(node)

def maze_path_queue(x1,y1,x2,y2):
    queue = deque()
    queue.append((x1, y1, -1))  # 右边进
    path = []　　# 存储出队元素
    while len(queue) > 0:
        curNode = queue.popleft()  # 左边出
        path.append(curNode)　　# len(path)-1为最后一个元素
        if curNode[0] == x2 and curNode[1] == y2:　　# 终点
            print_r(path)
            return True
        for dir in dirs:
            nextNode = dir(curNode[0], curNode[1])　　# 走一个方向
            if maze[nextNode[0]][nextNode[1]] == 0:
　　　　　　　　　　# 后续节点进队
                queue.append((nextNode[0], nextNode[1], len(path)-1))  # len(path)-1为下标记录上个节点带这个节点来的
                maze[nextNode[0]][nextNode[1]] = 2  # 标记已经走过
    else:
        print("没有路")
        return False

maze_path_queue(1,1,8,8)