【BFS】——poj3984——模拟队列

                                                  迷宫问题

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 15495		Accepted: 9205

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<iostream>
#include<string.h>
#include<stdio.h>
using namespace std;

int mp[10][10];
int vis[10][10];

struct point{
    int x,y;
    int father;
    point (int xx,int yy,int f) : x(xx),y(yy),father(f) {}
    point() {}
}temp;

int ax[4]={0,0,1,-1};
int ay[4]={1,-1,0,0};

point q[30];
int head,tail;

void print_road(int k)
{
    if(q[k].father!=-1)
    {
         print_road(q[k].father);
        printf("(%d, %d)\n",q[k].x,q[k].y);
    }
}

int main()
{
    memset(vis,0,sizeof(vis));

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

    head=0;
    tail=1;

    q[0]=point(0,0,-1);
    vis[0][0]=1;

    while(head!=tail)
    {
        temp=q[head];
        if(temp.x==4&&temp.y==4)
        {
            printf("(0, 0)\n");
            print_road(head);
            break;
        }

        for(int i=0;i<4;i++)
        {
            int xt=temp.x+ax[i];
            int yt=temp.y+ay[i];
            if(xt>=0&&xt<5&&yt>=0&&yt<5&&vis[xt][yt]==0&&mp[xt][yt]==0)
            {
                q[tail++]=point(xt,yt,head);
                vis[xt][yt]=1;
            }
        }
        head++;
    }
    /*for(int i=0;i<=tail;i++)
        cout<<q[i].x<<" "<<q[i].y<<" "<<q[i].father<<endl;*/
    return 0;
}