【一起来刷Python题】——20.解决迷宫问题

⭐今天有点慵懒，不知不觉时间过得很快，差点忘了刷题，坚持！总会有收货！⭐

          一个由0和1构成的二维数组中，假设1使可以移动到的点，0是不能移动到的点，如何从数组中间一个值为1的点出发，每次只能朝上、下、左、右四个方向移动一个单位，当移动到二维数组的边缘，即可得到问题的解。类似的问题都可以称为迷宫问题。

先把漂亮的结果放在这里...

 

程序代码：

dirs = [(0,1),(1,0),(0,-1),(-1,0)] # 当前位置四个方向上的偏移量
path = [] # 找到的路径
def mark(maze, pos): # 给迷宫maze的位置pos标“2”表示“到过了”
    maze[pos[0]][pos[1]] = 2
def passable(maze, pos): # 检查迷宫maze的位置pos是否可行
    return maze[pos[0]][pos[1]] == 0
def find_path(maze, pos, end):
    mark(maze, pos)
    if pos == end:
        print(pos, end=" ") # 已到达出口，输出这个位置。成功结束
        path.append(pos)
        return True
    for i in range(4):
        nextp = pos[0] + dirs[i][0], pos[1] +dirs[i][1]
        # 考虑下一个可能的方向
        if passable(maze, nextp): # 不可行的相邻位置不用管
            if find_path(maze, nextp, end):
                # 如果从nextp可达出口，输出这个位置。成功结束
                print(pos, end=" ")
                path.append(pos)
                return True
    return False
def see_path(maze, path): # 使找到的路径可视化
    for i, p in enumerate(path):
        if i == 0:
            maze[p[0]][p[1]] == "E"
        elif i == len(path) -1:
            maze[p[0]][p[1]] == "S"
        else:
            maze[p[0]][p[1]] == 3
    print("\n")
    for r in maze:
        for c in r:
            if c == 3:
                print('\033[0;31m' + "*" + " " + '\033[0m', end="")
            elif c == "S" or c == "E":
                print('\033[0;34m' + c + " " + '\033[0m', end="")
            elif c == 2:
                print('\033[0;32m' + "#" + " " + '\033[0m', end="")
            elif c == 1:
                print('\033[0;;40m' + " " *2 + '\033[0m', end="")
            else:
                print(" "*2, end="")
        print()

if __name__ == '__main__':
    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]

    ]
    start =(1,1)
    end = (10,12)
    find_path(maze, start, end)
    see_path(maze, path)

程序分析：

        首先将迷宫数字化，用一个二维的list（即list嵌套再list里）存储迷宫，将不可到达的位置用1表示，可到达的位置用0表示，并将已经到过的位置用2表示。使用递归算法求解的基本思路是：

▲ 每个时刻总有一个当前位置，开始时这个位置时迷宫入口；

▲ 如果当前位置就是出口，问题得到解决，退出即可；

▲ 否则，如果从当前位置已无路可走，当前的探查失败，回退一步；

▲ 取一个可行相邻位置用同样方式探查，如果从那里可以找到通往出口的路径，那么当前位置到出口的路径也就找到了。

        在整个计算开始时，把迷宫的入口（序列对）作为检查开始的当前位置，具体算法过程如下：

1）mark（记录）当前位置；

2）检查当前位置是否为出口，如果是则成功结束；

3）逐个检查当前位置的四邻是否可以通达出口(递归调用自身)；

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