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=0):x(a),y(b),t(c){}
    bool operator < (const node &a) const {
        return t>a.t;
    }
};
int d[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
int mp[5][5],px[5][5],py[5][5],vis[5][5];
void print(int x,int y)
{
    if(px[x][y]!=-1&&py[x][y]!=-1)
        print(px[x][y],py[x][y]);
    printf("(%d, %d)
",x,y);
}
void bfs()
{
    priority_queue<node>q;
    vis[0][0]=1;
    q.push(node(0,0));
    while(!q.empty())
    {
        node u=q.top();
        q.pop();
        int x=u.x,y=u.y;
        if(x==4&&y==4){
            print(x,y);
            return ;
        }
        for(int i=0;i<4;++i){
            int nx=x+d[i][0],ny=y+d[i][1];
            if(nx>=0&&nx<5&&ny>=0&&ny<5&&mp[nx][ny]!=1&&!vis[nx][ny]){
                vis[nx][ny]=1;
                px[nx][ny]=x,py[nx][ny]=y;
                q.push(node(nx,ny,u.t+1));
            }
        }
    }
}
int main()
{
    for(int i=0;i<5;++i)
        for(int j=0;j<5;++j)
            scanf("%d",&mp[i][j]);
    memset(vis,0,sizeof(vis));
    memset(px,-1,sizeof(px));
    memset(py,-1,sizeof(py));
    bfs();
    return 0;
}