POJ_1984 Navigation Nightmare 【并查集】

一、题面

POJ1984

二、分析

这题还是比较有意思的一题。

首先需要清楚的是，这题与普通并查集的区别在于它的节点之间的权值是二维的，因为是曼哈顿距离，肯定不能直接存距离，这样将不利于后面的路径压缩更新。

再看如何解题，先要把输入的数据存起来，因为后面是询问，关于方向的处理直接用正负即可。

存好数据后，每次进行询问时，对询问时间点前的进行合并，在并查集的路径压缩里注意这里还是使用了矢量的思想，具体的可以画两个矢量就出来了。

当查询的父节点相同时，表示是连通的，直接算曼哈顿距离就可以了。

当查询的父节点不相同时，表示不是连通的，输出-1。

三、AC代码

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

using namespace std;

const int MAXN = 4e4+4;
//X Y 表示当前节点到父节点的X， Y相对距离 
//DX DY 表示 输入的两个节点 X， Y相对距离
int X[MAXN], Y[MAXN], DX[MAXN], DY[MAXN];
int First[MAXN], Second[MAXN];
int Par[MAXN];

void Init()
{
    memset(X, 0, sizeof(X));
    memset(Y, 0, sizeof(Y));
    memset(Par, -1, sizeof(Par));
}

int Find(int a)
{
    if(Par[a] == -1)    return a;
    int t = Par[a];
    Par[a] = Find(Par[a]);
    X[a] += X[t];
    Y[a] += Y[t];
    return Par[a];
}

void Union(int a, int b, int dx, int dy)
{
    int fa = Find(a);
    int fb = Find(b);
    if(fa != fb)
    {
        Par[fa] = fb;
        X[fa] = X[b] + dx - X[a];
        Y[fa] = Y[b] + dy - Y[a]; 
    }
}

int main()
{
    //freopen("input.txt", "r", stdin);
    int N, M, T;
    while(scanf("%d %d", &N, &M)!=EOF)
    {
        Init();
        int len;
        char c;
        for(int i = 0; i < M; i++)
        {
            scanf("%d %d %d %c", &First[i], &Second[i], &len, &c);
            switch(c)
            {
                case 'E': DX[i] = len, DY[i] = 0; break;
                case 'W': DX[i] = 0-len, DY[i] = 0; break;
                case 'N': DX[i] = 0, DY[i] = len; break;
                case 'S': DX[i] = 0, DY[i] = 0-len; break;
            }
        }
        scanf("%d", &T);
        int t, k = 0;
        int u, v;
        for(int i = 0; i < T; i++)
        {
            scanf("%d %d %d", &u, &v, &t);
            for(k; k < t; k++)
            {
                Union(First[k], Second[k], DX[k], DY[k]);
            }
            int fu = Find(u);
            int fv = Find(v);
            if(fu == fv)
            {
                printf("%d
", abs(X[u] - X[v]) + abs(Y[u] - Y[v]));
            }
            else
            {
                printf("-1
");
            }
            
        }

    }
    return 0;
}