迷宫问题

最新推荐文章于 2024-06-16 14:11:05 发布

原创最新推荐文章于 2024-06-16 14:11:05 发布 · 301 阅读

0 ·

CC 4.0 BY-SA版权

华为笔试训练专栏收录该内容

4 篇文章

订阅专栏

题目描述

定义一个二维数组N*M（其中2<=N<=10;2<=M<=10），如5 × 5数组下所示：

int maze[5][5] = {

0, 1, 0, 0, 0,

0, 1, 0, 1, 0,

0, 0, 0, 0, 0,

0, 1, 1, 1, 0,

0, 0, 0, 1, 0,

};

它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。入口点为[0,0],既第一空格是可以走的路。

Input

一个N × M的二维数组，表示一个迷宫。数据保证有唯一解,不考虑有多解的情况，即迷宫只有一条通道。

Output

左上角到右下角的最短路径，格式如样例所示。

Sample Input

0 1 0 0 0

0 1 0 1 0

0 0 0 0 0

0 1 1 1 0

0 0 0 1 0

Sample Output

(0, 0)

(1, 0)

(2, 0)

(2, 1)

(2, 2)

(2, 3)

(2, 4)

(3, 4)

(4, 4)

输入描述:

输入两个整数，分别表示二位数组的行数，列数。再输入相应的数组，其中的1表示墙壁，0表示可以走的路。数据保证有唯一解,不考虑有多解的情况，即迷宫只有一条通道。

输出描述:

左上角到右下角的最短路径，格式如样例所示。

示例1

输入

复制

输出

复制

(0,0)
(1,0)
(2,0)
(2,1)
(2,2)
(2,3)
(2,4)
(3,4)
(4,4)

# 栈与回溯法解决迷宫问题
def MazeTrack(maze, start, end):
    # 迷宫问题，采用栈与回溯法，并返回所有路径（本题只有一个路径，也即最优路径）
    # 输入迷宫矩阵maze，入口位置坐标start，出口位置坐标end，输出路径pathStack
    pathStack = [start]  # 入口start入栈
    mark(maze, start)  # 标记入口start
    rows = len(maze)  # 迷宫maze的行数
    cols = len(maze[0])  # 迷宫maze的列数
    direction = [[0, 1], [1, 0], [0, -1], [-1, 0]]
    while pathStack:  # pathSatck不为空
        cur = pathStack[-1]  # 当前位置cur
        for i in range(4):  # 按当前位置的右→下→左→上的顺序，检查下一个可能的位置
            nxt = [cur[0] + direction[i][0], cur[1] + direction[i][1]]
            if nxt == end:  # nxt为出口end
                pathStack.append(nxt)
                return pathStack
            if -1 < nxt[0] < rows and -1 < nxt[1] < cols:  # 判断下一位置是否还在迷宫内
                # nxt还在迷宫内部，接下来判断是否可以走
                if passable(maze, nxt):  # nxt可以走
                    pathStack.append(nxt)  # nxt添加到路径pathStack
                    mark(maze, nxt)  # 标记nxt
                    break  # 退出内层循环
                else:  # nxt不可以走
                    continue  # 继续下一次循环
            else:
                # nxt不在迷宫内部，继续下一次循环
                continue
        if pathStack[-1] == cur:  # 检查完当前位置的所有下一个位置后，当前位置未变，无路可走
            pathStack.pop()  # 回溯
        else:  # 当前位置变了，有路可走
            continue  # 继续向下走
def mark(maze, pos):
    # 标记迷宫maze已经搜索过的位置pos，避免重复搜索
    maze[pos[0]][pos[1]] = 2
def passable(maze, pos):
    # 判断迷宫maze中位置pos是否可以走
    return maze[pos[0]][pos[1]] == 0
if __name__ == '__main__':
    while True:
        try:
            Line1 = input().split(' ')
            N, M = int(Line1[0]), int(Line1[1])
            maze = [[] for i in range(N)]
            for i in range(N):
                Line = input().split(' ')
                for j in range(M):
                    maze[i].append(int(Line[j]))
            start = [0, 0]
            end = [N - 1, M - 1]
            path = MazeTrack(maze, start, end)
            for i in range(len(path)):
                print('({0},{1})'.format(path[i][0], path[i][1]))
        except:
            break