POJ-3894 迷宫问题 （BFS+路径还原）

定义一个二维数组：

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表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。

Input

一个5 × 5的二维数组，表示一个迷宫。数据保证有唯一解。

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)

题目分析：BFS路径还原的方法是记录每一个节点的前一个节点，并不断更新。递归输出。

代码如下：

 1 # include<iostream>
 2 # include<cstdio>
 3 # include<queue>
 4 # include<cstring>
 5 # include<algorithm>
 6 using namespace std;
 7 struct node
 8 {
 9     int x,y,t;
10     node(){}
11     node(int a,int b,int c=0):x(a),y(b),t(c){}
12     bool operator < (const node &a) const {
13         return t>a.t;
14     }
15 };
16 int d[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
17 int mp[5][5],px[5][5],py[5][5],vis[5][5];
18 void print(int x,int y)
19 {
20     if(px[x][y]!=-1&&py[x][y]!=-1)
21         print(px[x][y],py[x][y]);
22     printf("(%d, %d)\n",x,y);
23 }
24 void bfs()
25 {
26     priority_queue<node>q;
27     vis[0][0]=1;
28     q.push(node(0,0));
29     while(!q.empty())
30     {
31         node u=q.top();
32         q.pop();
33         int x=u.x,y=u.y;
34         if(x==4&&y==4){
35             print(x,y);
36             return ;
37         }
38         for(int i=0;i<4;++i){
39             int nx=x+d[i][0],ny=y+d[i][1];
40             if(nx>=0&&nx<5&&ny>=0&&ny<5&&mp[nx][ny]!=1&&!vis[nx][ny]){
41                 vis[nx][ny]=1;
42                 px[nx][ny]=x,py[nx][ny]=y;
43                 q.push(node(nx,ny,u.t+1));
44             }
45         }
46     }
47 }
48 int main()
49 {
50     for(int i=0;i<5;++i)
51         for(int j=0;j<5;++j)
52             scanf("%d",&mp[i][j]);
53     memset(vis,0,sizeof(vis));
54     memset(px,-1,sizeof(px));
55     memset(py,-1,sizeof(py));
56     bfs();
57     return 0;
58 }