广搜记录路径

E - 广搜记录路径 基础

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

Submit Status Practice POJ 3984

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)


这应该是最简单的BFS了吧。不过我还是第一次做BFS记录路径的题目，不容易啊，终于会输出路径了，呵呵。
其实也蛮简单的，在node点中多开一个int型指针，记录由上一个扩展而来的位子，最后把记录输入进栈，后入先出，反转过来就好。

#include"iostream"
#include"stack"
using namespace std;
int a[6][6];
int book[6][6];
struct node
{
    int x;
    int y;
    int f;
};
int nex[4][2]={{1,0},{0,1},{-1,0},{0,-1}};

void BFS()
{
struct node que[50];
stack<struct node>s;
int head,tail;
head=tail=1;
struct node b,t;
b.x=b.y=0;
b.f=0;
que[tail]=b;
book[0][0]=1;
tail++;
while(head<tail)
{
    struct node e;
    e=que[head];

    if(e.x==4&&e.y==4)
    {
        while(que[head].f!=0)
        {
          s.push(que[head]);
          que[head]=que[que[head].f];
        }
        s.push(que[head]);
       while(!s.empty())
        {
        cout<<'('<<s.top().x<<", "<<s.top().y<<')'<<endl;
        s.pop();
        }
        break;
    }
    for(int i=0;i<=3;i++)
    {
        t.x=e.x+nex[i][0];
        t.y=e.y+nex[i][1];
        if(t.x<0||t.y<0||t.x>4||t.y>4)
            continue;
        if(a[t.x][t.y]==1||book[t.x][t.y]!=0)
            continue;
        book[t.x][t.y]=1;
        t.f=head;
        que[tail]=t;
        tail++;
    }
     head++;
   //  cout<<head<<' '<<tail<<' '<<e.x<<' '<<e.y<<endl;
}
}






int main()
{
    for(int i=0;i<5;i++)
        for(int j=0;j<5;j++)
        cin>>a[i][j];

        BFS();

        // cout<<endl;

        /* for(int i=0;i<5;i++)
         {
            for(int j=0;j<5;j++)
               cout<<book[i][j]<<' ';
               cout<<endl;
         }*/
    return 0;
}




*******上次用数组自己做了个队列，但不太方便，这次又用STL做了一个********

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <stack>
using namespace std;

int a[5][5],nex[4][2]={{1,0},{0,1},{-1,0},{0,-1}};
struct node
{
int x,y;
int fx,fy;
int flag;
}book[5][5];
stack<node> path;

void Init()
{
for(int i=0;i<5;i++)
{
for(int j=0;j<5;j++)
cin>>a[i][j];
}
}

void BFS()
{
queue<int>que;
memset(book,0,sizeof(book));
int sx=0,sy=0,qx=4,qy=4;
que.push(sx*5+sy);
book[sx][sy].flag=1;
book[sx][sy].x=sx;
book[sx][sy].y=sy;
book[sx][sy].fx=-1;
book[sx][sy].fy=-1;
while(!que.empty())
{
int temp=que.front();
que.pop();
int nx=temp/5,ny=temp%5;
if(nx==qx&&ny==qy)
{
int ik=qx,jk=qy;
while(book[ik][jk].fx!=-1)
{
path.push(book[ik][jk]);
book[ik][jk]=book[book[ik][jk].fx][book[ik][jk].fy];
}
struct node cc;
cc.x=0;cc.y=0;
path.push(cc);
return;
}
for(int k=0;k<=3;k++)
{
int px=nx+nex[k][0],py=ny+nex[k][1];
if(a[px][py]||book[px][py].flag) continue;
if(px<0||py<0||px>=5||py>=5) continue;
book[px][py].flag=1;
book[px][py].x=px;
book[px][py].y=py;
book[px][py].fx=nx;
book[px][py].fy=ny;
que.push(px*5+py);
}
}
}

void Print()
{
while(!path.empty())
{
cout<<"("<<path.top().x<<", "<<path.top().y<<")"<<endl;
path.pop();
}
}

int main()
{
Init();
BFS();
Print();
return 0;
}