poj 1984 - Navigation Nightmare(并查集)

思路：(from:http://hi.baidu.com/strongoier/item/8665de0cd915571e3a53eea8)

题目比较长，大意是说给N个点和M条边，每条边有方向（东南西北）和长度，再给Q个询问，第i个询问查询两个点之间在Ti时刻的曼哈顿距离（即如果前Ti条边能使这两个点连通则输出答案，否则输出-1）。

由于要维护图的连通性，我们考虑使用并查集。很显然这题要离线做，按询问的时间排序，依次往图中加入边。

那么，判断连通就很简单了，关键问题在于距离的维护。我们对于并查集上的每个集合，不仅要维护其father，还要维护与father的x、y坐标偏移量。路径压缩的过程中，每次找完father就加上father的x、y坐标偏移量，这样压完以后很容易就得到了与根的偏移量。而合并两个集合时，第二个集合的根的新偏移量就等于第一个集合的当前结点到根的偏移量 -  第二个集合的当前结点到根的偏移量 + 新加的边带来的偏移量。

代码如下：

const int M = 40005;
const int N = 10005;
struct Node
{
    int x, y;
}node[M];
struct Query
{
    int id, a, b, time;
    bool operator < (const Query& tmp) const
    {
        return time < tmp.time;
    }
}query[N];
struct Edge
{
    int a, b, dx, dy;
}edge[M];
int p[M], ans[N], dir[5][2] = {{0,-1},{0,1},{-1,0},{1,0}};
int find(int x)
{
    int tmp = p[x];
    p[x] = (p[x]==x?x:find(p[x]));
    node[x].x += node[tmp].x;
    node[x].y += node[tmp].y;
    return p[x];
}
int main()
{
    int n, m, k, l;
    char d;
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; ++i) {p[i] = i; node[i].x = node[i].y = 0; }
    for(int i = 0; i < m; ++i)
    {
        scanf("%d%d%d %c", &edge[i].a, &edge[i].b, &l, &d);
        int tmp;
        switch(d)
        {
            case 'N': tmp = 0; break;
            case 'S': tmp = 1; break;
            case 'W': tmp = 2; break;
            case 'E': tmp = 3; break;
        }
        edge[i].dx = dir[tmp][0]*l;
        edge[i].dy = dir[tmp][1]*l;
    }

    scanf("%d", &k);
    for(int i = 0; i < k; ++i)
    {
        query[i].id = i;
        scanf("%d%d%d", &query[i].a, &query[i].b, &query[i].time);
    }
    sort(query, query+k);
    for(int i = 0, j = 0; i < k; ++i)
    {
        for(; j < query[i].time; ++j)
        {
            int a = edge[j].a;
            int b = edge[j].b;
            int dx = edge[j].dx;
            int dy = edge[j].dy;
            int x = find(a);
            int y = find(b);
            if(x != y)
            {
                p[x] = y;
                node[x].x = node[b].x - node[a].x - dx;
                node[x].y = node[b].y - node[a].y - dy;
            }
        }
        int a = query[i].a;
        int b = query[i].b;
        int x = find(a);
        int y = find(b);
        if(x != y) ans[query[i].id] = -1;
        else ans[query[i].id] = abs(node[a].x-node[b].x)+abs(node[a].y-node[b].y);
    }
    for(int i = 0; i < k; ++i) printf("%d\n", ans[i]);
    return 0;
}