43 迷宫问题

题目描述
定义一个二维数组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
输入
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
输出
(0,0)
(1,0)
(2,0)
(2,1)
(2,2)
(2,3)
(2,4)
(3,4)
(4,4)
思路：将满足向下or向上的路径加入队列中；按坐标形式输出队列

def printzuobiao(road):
    for each in road:
        print('(%d,%d)'%(each[0],each[1]))
def walk(i,j,maze,x,y):
    road=[[i,j]]
    while i!=x-1 or j!=y-1:#注意循环条件
        if i<x-1 and maze[i+1][j]==0:
            i+=1
            road.append([i,j])
        elif j<y-1 and maze[i][j+1]==0:
            j+=1
            road.append([i,j])
    return road
while True:
    try:
        [m,n]=[int(i) for i in input().split()]
        maze=[]
        for i in range(m):#每行为一个列表
            maze.append([int(i) for i in input().split()])
        # print(maze)
        lujing=walk(0,0,maze,m,n)#从（0，0）开始走到（m-1，n-1）
        printzuobiao(lujing)
    except:
        break

#用来判断坐标是否合法

import sys
def check_valid(mg, x, y):
    if x >= 0 and x < len(mg) and y >= 0 and y < len(mg[0]) and mg[x][y] == 1:
        return True
    else:
        return False


# 迷宫结果优化
def process(step):
    # 先识别哪些无路可走的点的下一个点
    change_records = []
    for i in range(len(step) - 1):
        if (abs(step[i][0] - step[i + 1][0]) == 0 and abs(step[i][1] - step[i + 1][1]) == 1) or (abs(step[i][0] - step[i + 1][0]) == 1 and abs(step[i][1] - step[i + 1][1]) == 0):
            pass
        else:
            change_records.append(i + 1)
    # print(change_records)

    # 然后根据这些点识别出这个点的最远回退点
    clip_nums = []
    for i in change_records:
        for j in range(i):
            if (abs(step[j][0] - step[i][0]) == 0 and abs(step[j][1] - step[i][1]) == 1) or \
                    (abs(step[j][0] - step[i][0]) == 1 and abs(step[j][1] - step[i][1]) == 0):
                break
        clip_nums.append((j, i))
    # print(clip_nums)

    # 注意回退点之间的包含关系, 逆序处理, 是为了规避顺序对列表进行处理后下标偏移的问题
    record = []
    for i in clip_nums[::-1]:
        if not (i[0] in record or i[1] in record):
            step = step[:i[0] + 1] + step[i[1]:]
        record += list(range(i[0], i[1]))
    print(step)


step = []


def walk(mg, x, y):
    global step
    if x == 0 and y == 0:
        step.append((x, y))
        process(step)
        print("Walk success!")
        sys.exit()

    if check_valid(mg, x, y):
        step.append((x, y))
        mg[x][y] = 2
        walk(mg, x, y + 1)
        walk(mg, x, y - 1)
        walk(mg, x - 1, y)
        walk(mg, x + 1, y)


mg = [[1, 0, 1, 1, 1, 0],
      [1, 1, 1, 0, 1, 1],
      [0, 0, 0, 1, 0, 1],
      [0, 1, 1, 1, 0, 1],
      [0, 1, 0, 1, 1, 1],
      [1, 1, 1, 0, 0, 0]]

walk(mg, 5, 0)  # 从5, 0这个点开始走迷宫, 出口为0, 0