迷宫问题的三种求解方法（递归求解、回溯求解和队列求解）
目录
一、迷宫问题的三种求解方法
递归求解
回溯求解
队列求解
二、华为迷宫问题
一、迷宫问题的三种求解方法
在迷宫问题中，给定入口和出口，要求找到路径。本文将讨论三种求解方法，递归求解、回溯求解和队列求解。
在介绍具体算法之前，先考虑将迷宫数字化。这里将迷宫用一个二维的list存储（即list嵌套在list里），将不可到达的位置用1表示，可到达的位置用0表示，并将已经到过的位置用2表示。
递归求解
递归求解的基本思路是：
每个时刻总有一个当前位置，开始时这个位置是迷宫人口。
如果当前位置就是出口，问题已解决。
否则，如果从当前位置己无路可走，当前的探查失败，回退一步。
取一个可行相邻位置用同样方式探查，如果从那里可以找到通往出口的路径，那么从当前位置到出口的路径也就找到了。
在整个计算开始时，把迷宫的人口（序对）作为检查的当前位置，算法过程就是：
mark当前位置。
检查当前位置是否为出口，如果是则成功结束。
逐个检查当前位置的四邻是否可以通达出口（递归调用自身）。
如果对四邻的探索都失败，报告失败。
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)
代码中see_path函数可以在控制台直观打印出找到的路径，打印结果如下:
(10, 12) (9, 12) (8, 12) (7, 12) (6, 12) (5, 12) (5, 11) (5, 10) (6, 10) (6, 9) (6, 8) (6, 7) (6, 6) (6, 5) (6, 4) (6, 3) (7, 3) (7, 2) (7, 1) (6, 1) (5, 1) (4, 1) (3, 1) (2, 1) (1, 1)
可以看到，路径是从出口到入口的位置。
S是入口位置 ，E是出口位置，*代表找到的路径，#代表探索过的路径。
回溯求解
在回溯解法中，主要是用栈来存储可以探索的位置。利用栈后进先出的特点，在一条分路上探索失败时，回到最近一次存储的可探索位置。这是一种深度优先搜索的方法。
def maze_solver(maze,start,end):
if start==end:
print(start)
return
st=SStack()
mark(maze,start)
st.push((start,0)) #入口和方向0的序对入栈
while not st.is_empty(): #走不通时回退
pos,nxt=st.pop() #取栈顶及其检查方向
for i in range(nxt,4): #依次检查未检查方向，算出下一位置
nextp = pos[0] + dirs[i][0], pos[1] + dirs[i][1]
if nextp==end:
print_path(end,pos,st) #到达出口，打印位置
return
if passable(maze,nextp): #遇到未探索的新位置
st.push((pos,i+1)) #原位置和下一方向入栈
mark(maze,nextp)
st.push((nextp,0)) #新位置入栈
break #退出内层循环，下次迭代将以新栈顶作为当前位置继续
print("找不到路径")队列求解
队列求解算法中，以队列存储可以探索的位置。利用队列先进先出的特点，实现在每个分支上同时进行搜索路径，直到找到出口。这是一种广度优先搜索的方法。
def maze_solver_queue(maze,start,end):
path.append(start)
if start==end:
print("找到路径")
return
qu=SQueue()
mark(maze,start)
qu.enqueue(start) #start位置入队
while not qu.is_empty(): #还有候选位置
pos=qu.dequeue() #取出下一位置
for i in range(4): #检查每个方向
nextp = pos[0] + dirs[i][0], pos[1] + dirs[i][1]
if passable(maze,nextp): #找到新的探索方向
if nextp==end: #是出口，成功
print("找到路径")
path.append(end)
return
mark(maze,nextp)
qu.enqueue(nextp) #新位置入队
path.append(nextp)
print("未找到路径")但队列求解方法，不能直接得出找到的具体路径，要得到找到的路径还需要其他存储结构（如链表）。
二、华为迷宫问题
题目：
定义一个二维数组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
左上角到右下角的最短路径
1、回溯法基本思想
回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择。
2、迷宫问题结题思路
从起始点开始，判断每个位置上下左右方格是路（0）还是墙（0）。若是路（0），前进一步，将下一个方格标记为2（表示走过），并将其坐标加入（append）路径列表（path）。路径列表表示走过的所有路径，索引最大处的坐标为当前位置。若上下左右都走不通，返回上一坐标进行其他方向判断，直到最后到达终点，输出path,即为迷宫正确出逃路径。
3、代码
direction=[(-1,0),(1,0),(0,-1),(0,1)]
def maze_deal(start,end,maze):
path=[]
path.append(start)
maze[0][0]=2 #走过的路径记为2
while len(path)>0:
cur=path[-1]
if cur[0]==end[0]and cur[1]==end[1]:
for i in path:
print("(%d,%d)"%(i[0],i[1]))
return True
for i in direction:
nextnode=(cur[0]+i[0],cur[1]+i[1])
if 0<=nextnode[0]<=end[0] and 0<=nextnode[1]<=end[1]:
if maze[nextnode[0]][nextnode[1]] ==0:
path.append(nextnode)
maze[nextnode[0]][nextnode[1]]=2
break
else:
path.pop()
else:
print("no access path")
return False
while True:
try :
[m,n]=[int(i)for i in input().split()]
maze=[]
for i in range(m):
maze.append([int(j)for j in input().split()])
start=(0,0)
end=(m-1,n-1)
maze_deal(start,end,maze)
except:
break
"""
deals=[lambda x,y:(x+1,y),#向下
lambda x,y:(x,y+1),#向右
lambda x,y:(x-1,y),#向上
lambda x,y:(x,y-1),#向左
]
def deal_maze(start,end,maze):
path=[] #走过的路径
path.append(start)
maze[0][0]=2 #走过的路径记为2
while len(path)>0:
curnode=path[-1]
if curnode[0]==end[0] and curnode[1]==end[1]:
#print('到达终点')
for i in path:
#print(i)
print("(%d,%d)"%(i[0],i[1]))
return True
for deal in deals:
nextnode=deal(curnode[0],curnode[1])
if 0<=nextnode[0]<=end[0] and 0<=nextnode[1]<=end[1]:
#判断没有出迷宫
if maze[nextnode[0]][nextnode[1]]==0:
path.append(nextnode)
maze[nextnode[0]][nextnode[1]]=2
break
else:
path.pop()
else:
#print('没有路')
return False
while True:
try:
[a,b]=list(map(int,input().split())) #a为行,b为列
maze=[] #迷宫本身
for i in range(a):
maze.append([int(j) for j in input().split()])
deal_maze((0,0),(a-1,b-1),maze)
except:
break
"""
"""
def printzuobiao(LU):
for i in LU:
print('(%d,%d)' % (i[0], i[1]))
def migong(i, j, MG, I, J):
lu = [[i, j]]
while i != I-1 or j != J-1:
if i < I-1 and MG[i+1][j] == 0:
i += 1
lu.append([i, j])
elif j < J-1 and MG[i][j+1] == 0:
j += 1
lu.append([i, j])
return lu
while True:
try:
[a, b] = [int(i) for i in input().split()]
m = []
for i in range(a):
m.append([int(i) for i in input().split()])
lujing = migong(0, 0, m, a, b)
printzuobiao(lujing)
except:
break
"""
输入：
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)
4、while/for…else解释
代码里面的while循环和for循环后面加了else
for, while循环如果在计数器用尽跳出时，用不用else语句对结果都是没有影响的，所以只有在for, while循环非正常结束时，才会体现出效果，比如：通过break跳出循环，这时也会跳过else语句块，直接执行else之后的语句。可以在else语句块中写一些不通过break语句跳出时才执行的代码
参考链接：
https://blog.csdn.net/ya_shy/article/details/104907591
https://blog.csdn.net/qq_29681777/article/details/83719680