迷宫问题（bfs+记录路径）

题目链接：http://acm.hust.edu.cn/vjudge/contest/view.action?cid=105278#problem/K

K - 迷宫问题

Time Limit:1000MS     Memory Limit:65536KB     64bit IO Format:%I64d & %I64u

Submit Status

Description

定义一个二维数组：

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)

题解：注意暴力搜索记录路径的题，一个学到的很好的方法就是开一个数组记录当前节点的父亲节点，然后最后输出的时候，从最后一个点依次向前面找，按照父亲找父亲的方法找下去，最后就是路径了

 #include<cstdio>
 #include<cstring>
 #include<stack>
 #include<queue>
 #include<string>
 using namespace std;
 int mp[][];
 struct Node{
     int x;
     int y;
 };
 Node fa[][];
 bool vis[][];
 bool ck(Node k)
 {
     if(k.x<=&&k.x>=&&k.y>=&&k.y<=) return true;
     return false;
 }

 int go[][] = {{,},{-,},{,},{,-}};

 void bfs(){
     queue<Node>q;
     memset(vis,,sizeof(vis));
     Node tm;
     tm.x = ;
     tm.y = ;
     q.push(tm);
     vis[][] = ;
     while(!q.empty()){
         Node tm1 = q.front();q.pop();
         Node fl;
         for(int i = ; i < ; i++){
             fl.x = tm1.x+go[i][];
             fl.y = tm1.y+go[i][];
             if(ck(fl)&&vis[fl.x][fl.y]==&&mp[fl.x][fl.y]==){
                 q.push(fl);
                 vis[fl.x][fl.y] = ;
                 fa[fl.x][fl.y] = tm1;
             }
         }
     }
 }

 int main()
 {
     for(int i = ; i < ; i++)
         for(int j = ; j < ; j++)
             scanf("%d",&mp[i][j]);
     bfs();
     stack<Node>v;
     Node ff = fa[][];
     while(!(ff.x==&&ff.y==)){
         v.push(ff);
         ff = fa[ff.x][ff.y];
     }
     printf("(0, 0)\n");
     while(!v.empty()){
         printf("(%d, %d)\n",v.top().x,v.top().y);
         v.pop();
     }
     printf("(4, 4)\n");
     return ;
 }