python带我们走迷宫

    当拿到如下迷宫地图时，给定入口和出口，怎么找到出去的路径呢？这么找到最快的路径呢？python就可以实现这个小功能哦~

在整个计算开始时，把迷宫的人口（序对）作为检查的当前位置，算法过程就是：

• mark当前位置。

• 检查当前位置是否为出口，如果是则成功结束。

• 逐个检查当前位置的四邻是否可以通达出口。

• 如果对四邻的探索都失败，报告失败。

方法一、找到出去的路

maze = [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1],
        [1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1],
        [1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1],
        [1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1],
        [1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1],
        [1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1],
        [1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1],
        [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1],
        [1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1],
        [1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]
def maze_path_stack(x1, y1, x2, y2):
    """
    用栈求解迷宫问题——深度优先搜索算法
    :param x1: 起点x位置
    :param y1: 起点y位置
    :param x2: 终点x位置
    :param y2: 终点y位置
    :return:
    """
    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)   # 当前位置右面
    ]
    stack = []  # 定义一个栈，用来存放路径
    stack.append((x1, y1))  # 把当前位置压栈
    while len(stack) > 0:  # 只要栈不空就一直找路
        curNode = stack[-1]  # 当前的节点
        if curNode[0] == x2 and curNode[1] == y2:
            print("找到路了.")
            for i in stack:
                print(i)
            return True
        for dir in dirs:
            nextNode = dir(curNode[0], curNode[1])
            if maze[nextNode[0]][nextNode[1]] == 0:
                stack.append(nextNode)
                maze[nextNode[0]][nextNode[1]] = 2  # 2：表示已经走过了
                break
        else:
            maze[nextNode[0]][nextNode[1]] = 2
            stack.pop()
    else:
        print("没有路！")
        return False




maze_path_stack(1, 1, 10, 12)

方法二、找到最近的出路

from collections import deque
def print_path(path):
    curNode = path[-1]  # 迷宫的终点
    realPath = []  # 存储真实的路径
    while curNode[2] != -1:  # 只要没有到达开始位置就继续往真实路径中添加
       realPath.append(curNode[0:2])
       curNode = path[curNode[2]]
    realPath.append(curNode[0:2])  # 路径的倒序
    realPath.reverse()
    for node in realPath:
        print(node)
def maze_path_queue(x1, y1, x2, y2):
    """
    用队列求解迷宫问题——广度优先搜索算法
    :param x1: 起点x位置
    :param y1: 起点y位置
    :param x2: 终点x位置
    :param y2: 终点y位置
    :return:
    """
    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)   # 当前位置右面
    ]
    queue = deque()  # 队列中存放的是当前正在考虑的节点位置
    queue.append((x1, y1, -1))   # x的位置，y的位置，该（x，y）位置是由哪个位置走过来的
    path = []
    while len(queue) > 0:  # 之后当前考虑的节点还有，就证明还可以走，当queue为空，证明没有往下走的路了
        curNode = queue.popleft()
        path.append(curNode)
        if curNode[0] == x2 and curNode[1] == y2:
            print("找到路了")
            print_path(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))  # 后续节点进队，记录哪个节点带他来的
                maze[nextNode[0]][nextNode[1]] = 2  # 2表示已经走过的节点
    else:
        print("没有路。")
        return False
maze_path_queue(1, 1, 10, 12)

S是入口位置 ，E是出口位置，*代表找到的路径，#代表探索过的路径。