Python算法——如何求解迷宫问题(回溯法)

要求：

       给定一个N*N的迷宫，从迷宫左上角(对应矩阵[0][0])走到迷宫右下角(对应矩阵[N-1][N-1])，只能向两方向移动：向右或向下。在迷宫中0表示没有路，1表示有路。

分析：

       这里使用回溯法，当碰到死胡同时，回溯到前一步，然后从前一步出发继续寻找可达路径。

       申请一个结果矩阵用来标记移动路径

       if 到达了目的地

          打印输出解决方案

      else

          (1)在结果矩阵中标记当前为1(1表示移动的路径)

          (2)向右前进一步，然后递归检查，走完这一步后，判断是否存在到终点的可达路线。

         (3)如果（2）中的移动方向导致没有通往终点的路径，那么选择向下移动，然后检查这种移动方法是否存在可以到达终点的可达路线。

         (4)如果上面的移动方法导致没有可达的路径，那么标记当前的单元格在结果矩阵中为0，返回false，并回溯到前一步中。

实现代码：

# -*- coding:utf-8 -*-
class Maze():
    def __init__(self):
        self.N = 4
    #打印从起点到终点的路线
    def printSolution(self,sol):
        i = 0
        while i < self.N:
            j = 0
            while j < self.N:
                print(sol[i][j],'',end="")
                j += 1
            print()
            i += 1

    #判断x和y是否是一个合理的单元
    def isSafe(self,maze,x,y):
        return x >= 0 and x < self.N and y >= 0 and y < self.N and maze[x][y] == 1

    '''
    使用回溯法找到一条从左上角到右下角的路径，maze表示迷宫，x、y表示起点，sol存储结果
    '''
    def getPath(self,maze,x,y,sol):
        #到达目的地
        if x == self.N-1 and y == self.N-1:
            sol[x][y] = 1
            return True
        #判断maze[x][y]是否是一个可走的单元
        if self.isSafe(maze,x,y):
            #标记当前单元为1
            sol[x][y] = 1
            #向右走一步
            if self.getPath(maze,x+1,y,sol):
                return True
            #向下走一步
            if self.getPath(maze,x,y+1,sol):
                return True
            #标记当前单元为0用来表示这条路不可行，然后回溯
            sol[x][y] = 0
            return False
        return False

if __name__ == "__main__":
    rat = Maze()
    maze = [[1,0,0,0],[1,1,0,1],[0,1,0,0],[1,1,1,1]]
    sol = [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]
    if not rat.getPath(maze,0,0,sol):
        print("不存在可达路径！")
    else:
        rat.printSolution(sol)

运行结果：

1 0 0 0 
1 1 0 0 
0 1 0 0 
0 1 1 1