POJ 1984 Navigation Nightmare （带权并查集）

题目给了N个点和某些点之间的距离，两个点之间的距离是有四个方向的，（N S W E），让你求任意两点的距离；

根据数据范围可以知道是用带权并查集做的，不过Rank要包含两个数据，南北和东西也就是普通带权并查集稍微改了一下~

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;

const int maxn = 1e6+5;
int n,m,father[maxn];
long long Rank[maxn][2];

struct Edge {
    int x,y,va;
    char direct[8];
} edge[maxn];

int query(int x) {
    if(x != father[x]) {
        int per = father[x];
        father[x] = query(father[x]);
        Rank[x][0] = Rank[x][0] + Rank[per][0];
        Rank[x][1] = Rank[x][1] + Rank[per][1];
    }
    return father[x];
}

struct Qu {
    int f,s,n,t,ans;
} qu[maxn];

bool tmp(Qu x,Qu y) {
    return x.n < y.n;
}

bool ttmp(Qu x,Qu y) {
    return x.t < y.t;
}

int main() {
    scanf("%d%d",&n,&m); 
    for(int i = 0;i <= n;i++)
        father[i] = i;
    memset(Rank,0,sizeof(Rank));
    for(int i = 1;i <= m;i++)
        scanf("%d%d%d%s",&edge[i].x,&edge[i].y,&edge[i].va,edge[i].direct);
    int mm;
    scanf("%d",&mm);
    for(int i = 1;i <= mm;i++) {
        scanf("%d%d%d",&qu[i].f,&qu[i].s,&qu[i].n);
        qu[i].t = i;
    }
    sort(qu+1,qu+1+mm,tmp); //提问不一定按照顺序来，所以要先排序，后面再按原来提问的顺序输出！
    int cnt = 1;
    for(int i = 1;i <= m;i++) {
        int a = query(edge[i].x);
        int b = query(edge[i].y);
        int x = edge[i].x;
        int y = edge[i].y;
        if(a != b) {
            father[b] = a;
            if(edge[i].direct[0] == 'E') {
                Rank[b][0] = (Rank[x][0] - Rank[y][0] + edge[i].va);
                Rank[b][1] = (Rank[x][1] - Rank[y][1]); //更新距离，这里要注意两个方向都要考虑好
            }
            else if(edge[i].direct[0] == 'W') {
                Rank[b][0] = (Rank[x][0] - Rank[y][0] - edge[i].va);
                Rank[b][1] = (Rank[x][1] - Rank[y][1]);
            }
            else if(edge[i].direct[0] == 'N') {
                Rank[b][1] = (Rank[x][1] - Rank[y][1] + edge[i].va);
                Rank[b][0] = (Rank[x][0] - Rank[y][0]);
            }
            else if(edge[i].direct[0] == 'S') {
                Rank[b][1] = (Rank[x][1] - Rank[y][1] - edge[i].va);
                Rank[b][0] = (Rank[x][0] - Rank[y][0]);
            }
        }
        while(i == qu[cnt].n) {
            int s = qu[cnt].f;
            int ss = qu[cnt].s;
            if(query(s) == query(ss)) {
                int ans = llabs(Rank[s][0] - Rank[ss][0]) + llabs(Rank[s][1] - Rank[ss][1]);
                qu[cnt].ans = ans;
            }
            else 
                qu[cnt].ans = -1;
            cnt++;
        }
    }
    sort(qu+1,qu+1+mm,ttmp);
    for(int i = 1; i <= mm;i++)
        printf("%d\n",qu[i].ans);
    /*for(int i = 1;i <= n;i++){
        query(i);
        printf("%I64d-%I64d\n",Rank[i][0],Rank[i][1]);
    }*/
    return 0;
}