POJ2049 Finding Nemo 【优先队列+BFS】

题目地址
Finding Nemo
Time Limit: 2000MS Memory Limit: 30000K

Description
Nemo is a naughty boy. One day he went into the deep sea all by himself. Unfortunately, he became lost and couldn’t find his way home. Therefore, he sent a signal to his father, Marlin, to ask for help.
After checking the map, Marlin found that the sea is like a labyrinth with walls and doors. All the walls are parallel to the X-axis or to the Y-axis. The thickness of the walls are assumed to be zero.
All the doors are opened on the walls and have a length of 1. Marlin cannot go through a wall unless there is a door on the wall. Because going through a door is dangerous (there may be some virulent medusas near the doors), Marlin wants to go through as few doors as he could to find Nemo.
Figure-1 shows an example of the labyrinth and the path Marlin went through to find Nemo.

We assume Marlin’s initial position is at (0, 0). Given the position of Nemo and the configuration of walls and doors, please write a program to calculate the minimum number of doors Marlin has to go through in order to reach Nemo.

Input
The input consists of several test cases. Each test case is started by two non-negative integers M and N. M represents the number of walls in the labyrinth and N represents the number of doors.
Then follow M lines, each containing four integers that describe a wall in the following format:
x y d t
(x, y) indicates the lower-left point of the wall, d is the direction of the wall – 0 means it’s parallel to the X-axis and 1 means that it’s parallel to the Y-axis, and t gives the length of the wall.
The coordinates of two ends of any wall will be in the range of [1,199].
Then there are N lines that give the description of the doors:
x y d
x, y, d have the same meaning as the walls. As the doors have fixed length of 1, t is omitted.
The last line of each case contains two positive float numbers:
f1 f2
(f1, f2) gives the position of Nemo. And it will not lie within any wall or door.
A test case of M = -1 and N = -1 indicates the end of input, and should not be processed.

Output
For each test case, in a separate line, please output the minimum number of doors Marlin has to go through in order to rescue his son. If he can’t reach Nemo, output -1.

Sample Input

8 9
1 1 1 3
2 1 1 3
3 1 1 3
4 1 1 3
1 1 0 3
1 2 0 3
1 3 0 3
1 4 0 3
2 1 1
2 2 1
2 3 1
3 1 1
3 2 1
3 3 1
1 2 0
3 3 0
4 3 1
1.5 1.5
4 0
1 1 0 1
1 1 1 1
2 1 1 1
1 2 0 1
1.5 1.7
-1 -1

Sample Output

5
-1

优先队列+BFS。
首先是建图。以每一个1*1的网格为一个点进行建图。并用两个三维数组（前两维坐标，最后一维表示方向）来储存墙和门。然后将给出的起点化为图中的点之后进行以穿过门数最少为优先条件的bfs（所以队列应该改用优先队列）。
不过这样的话会出现当没有什么墙的时候会往外围无限遍历的情况。所以除了要设定边界之外，还需要将优先队列的优先条件进行更改，改为“以穿过门数最少为最优先，如果穿过门数相等则以改点距终点的曼哈顿距离最短为最优先”这样的双重条件。
注意起点超出范围的情况，此时应该输出0。

#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
bool vis[300][300];
bool wall[300][300][4];
bool door[300][300][4];
int tur[4][2]={{-1,0},{0,1},{1,0},{0,-1}};
int m,n;
struct node
{
    int x,y,w;
    node(){}
    node(int xx,int yy,int ww)
    {
        x=xx;
        y=yy;
        w=ww;
    }
    bool operator < (const node &a)const
    {
        return a.w<w||(a.w==w&&(a.x+a.y<x+y));
    }
};
int bfs(int tx,int ty)
{
    priority_queue<node> q;
    q.push(node(tx,ty,0));
    while(!q.empty())
    {
        node p=q.top();
        q.pop();
        if(vis[p.x][p.y])continue;
        vis[p.x][p.y]=true;
        if(p.x==0&&p.y==0)return p.w;
        for(int i=0;i<4;i++)
        {
            node pp=p;
            pp.x+=tur[i][0];
            pp.y+=tur[i][1];
            if(pp.x<0||pp.x>=200||pp.y<0||p.y>=200)continue;
            if(wall[p.x][p.y][i])
            {
                if(door[p.x][p.y][i])pp.w++;
                else continue;
            }
            q.push(pp);
        }
    }
    return -1;
}
int main()
{
    while(scanf("%d%d",&n,&m)==2)
    {
        if(n==-1&&m==-1)break;
        memset(vis,0,sizeof(vis));
        memset(wall,0,sizeof(wall));
        memset(door,0,sizeof(door));
        for(int i=0;i<n;i++)
        {
            int x,y,d,t;
            scanf("%d%d%d%d",&x,&y,&d,&t);
            if(d==1)
            {
                for(int j=0;j<t;j++)
                {
                    wall[x-1][y+j][2]=true;
                    wall[x][y+j][0]=true;
                }
            }
            else
            {
                for(int j=0;j<t;j++)
                {
                    wall[x+j][y-1][1]=true;
                    wall[x+j][y][3]=true;
                }
            }
        }
        for(int i=0;i<m;i++)
        {
            int x,y,d;
            scanf("%d%d%d",&x,&y,&d);
            if(d==1)
            {
                door[x-1][y][2]=true;
                door[x][y][0]=true;
            }
            else
            {
                door[x][y-1][1]=true;
                door[x][y][3]=true;
            }
        }
        double tx,ty;
        scanf("%lf%lf",&tx,&ty);
        if(tx<0||tx>199||ty<0||ty>199)
        {
            printf("0\n");
            continue;
        }
        int txx=tx,tyy=ty;
        int ans=bfs(txx,tyy);
        printf("%d\n",ans);
    }
}