POJ 3984 迷宫问题 —————— BFS

Language:Default

迷宫问题

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 34377		Accepted: 19563

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)

Source

---

因为路径比较短，方向只有四个，在结构体里开一个数组，来保存到达这个点是从 $（0，0）$ 经过什么方向得到的

---

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<queue>

using namespace std;
int maze[6][6];
bool vis[6][6];
int d[4][2]={1,0, -1,0, 0,1, 0,-1};

struct node{
    int x,y,step;
    int cnt;
    int l[15];//保存方向
    bool operator < (const node &b)const
    {
        return step > b.step;
    }
};
node e1,e2;
node bfs()
{
    memset(vis,0,sizeof(vis));
    priority_queue<node> que;
    vis[0][0]=1;
    e1.x=0;
    e1.y=0;
    e1.step=0;
    que.push(e1);
    e1.cnt=0;
    while(que.size())
    {
        e1=que.top();que.pop();
        if(e1.x == 4 && e1.y ==4)
            return e1;

        for(int i=0;i<4;i++)
        {
            e2=e1;
            e2.x = e1.x + d[i][0];
            e2.y = e1.y + d[i][1];
            e2.l[e2.cnt++] = i ;//记录方向
            if(!vis[e2.x][e2.y] && maze[e2.x][e2.y]==0 && 0 <= e2.x && e2.x < 5 && 0 <= e2.y && e2.y <5)
            {
                vis[e2.x][e2.y]=1;
                que.push(e2);
            }
        }
    }
}
int main()
{
    for(int i=0;i<5;i++)
        for(int j=0;j<5;j++)
            scanf("%d",&maze[i][j]);
    node e=bfs();
    int x=0;
    int y=0;
    printf("(%d, %d)\n",0,0);
    for(int j=0;j<e.cnt;j++)
    {
        x += d[e.l[j]][0];
        y += d[e.l[j]][1];
        printf("(%d, %d)\n",x,y);
    }
    return 0;
}