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路径还原的方法是记录每一个节点的前一个节点，并不断更新。递归输出。

代码如下：

 # include<iostream>
 # include<cstdio>
 # include<queue>
 # include<cstring>
 # include<algorithm>
 using namespace std;
 struct node
 {
     int x,y,t;
     node(){}
     node(int a,int b,int c=):x(a),y(b),t(c){}
     bool operator < (const node &a) const {
         return t>a.t;
     }
 };
 int d[][]={{,},{-,},{,},{,-}};
 int mp[][],px[][],py[][],vis[][];
 void print(int x,int y)
 {
     if(px[x][y]!=-&&py[x][y]!=-)
         print(px[x][y],py[x][y]);
     printf("(%d, %d)\n",x,y);
 }
 void bfs()
 {
     priority_queue<node>q;
     vis[][]=;
     q.push(node(,));
     while(!q.empty())
     {
         node u=q.top();
         q.pop();
         int x=u.x,y=u.y;
         if(x==&&y==){
             print(x,y);
             return ;
         }
         for(int i=;i<;++i){
             int nx=x+d[i][],ny=y+d[i][];
             if(nx>=&&nx<&&ny>=&&ny<&&mp[nx][ny]!=&&!vis[nx][ny]){
                 vis[nx][ny]=;
                 px[nx][ny]=x,py[nx][ny]=y;
                 q.push(node(nx,ny,u.t+));
             }
         }
     }
 }
 int main()
 {
     for(int i=;i<;++i)
         for(int j=;j<;++j)
             scanf("%d",&mp[i][j]);
     memset(vis,,sizeof(vis));
     memset(px,-,sizeof(px));
     memset(py,-,sizeof(py));
     bfs();
     return ;
 }