UVA 11573 Ocean Currents --BFS+优先队列

采用优先队列做BFS搜索，d[][]数组记录当前点到源点的距离，每次出队时选此时eng最小的出队，能保证最先到达的是eng最小的。而且后来用普通队列试了一下，超时。。所以，能用优先队列的，就要用优先队列。

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <queue>
using namespace std;
#define N 1003

struct node
{
    int x,y;
    int eng;
    bool operator <(const node &a)const
    {
        return eng>a.eng;
    }
};

char ss[N][N];
int dis[N][N];
int n,m,res;
int dx[8] = {-1,-1,0,1,1,1,0,-1};
int dy[8] = {0,1,1,1,0,-1,-1,-1};

bool OK(int nx,int ny)
{
    if(nx >= 1 && nx <= n && ny >= 1 && ny <= m)
        return true;
    return false;
}

int bfs(node s,node t)
{
    priority_queue<node> que;
    while(!que.empty())
        que.pop();
    que.push(s);
    dis[s.x][s.y] = 0;
    while(!que.empty())
    {
        node tmp = que.top();
        que.pop();
        if(tmp.x == t.x && tmp.y == t.y)
            return tmp.eng;
        for(int i=0;i<8;i++)
        {
            node now;
            now.x = tmp.x + dx[i];
            now.y = tmp.y + dy[i];
            if(!OK(now.x,now.y))
                continue;
            if(ss[tmp.x][tmp.y] - '0' != i)
                now.eng = tmp.eng + 1;
            else
                now.eng = tmp.eng;
            if(dis[now.x][now.y] != -1 && now.eng >= dis[now.x][now.y])
                continue;
            dis[now.x][now.y] = now.eng;
            que.push(now);
        }
    }
    return -1;
}

int main()
{
    int i,j,q;
    node s,t;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        for(i=1;i<=n;i++)
            scanf("%s",ss[i]+1);
        scanf("%d",&q);
        while(q--)
        {
            memset(dis,-1,sizeof(dis));
            scanf("%d%d%d%d",&s.x,&s.y,&t.x,&t.y);
            s.eng = 0;
            res = bfs(s,t);
            printf("%d
",res);
        }
    }
    return 0;
}