POJ 1984 Navigation Nightmare （带权并查集，带图演示）

本来想着去做1985的树直径的

无奈这题输入时1984的

故做了一下

题意是
输入m组关系，x,y,l,d，意思是点x和点y相距l，并且y在x的d方向

再输入k个询问，x,y,t，意思是输出在t时刻点x和点y的曼哈顿距离，若未联通则输出-1（应该是默认输入的t是递增的）

很显然用并查集做，思路是把每个点的偏移量相对到父节点上面

struct F{
	int pre,w1,w0;
}f[40005];

pre是父节点，w1是距离父节点的南北方向偏移，而w0是距离父节点的东西方向偏移

我会用图说明

我们先看一下路径压缩

int Find(int x){
	if(f[x].pre==x)return x;
	int t=f[x].pre;
	f[x].pre=Find(f[x].pre);
	f[x].w0+=f[t].w0;
	f[x].w1+=f[t].w1;
	return f[x].pre;
}

就像下图演示的这样

记录下t节点，然后断开与t的连接，之后连接Newfather

下图为详细的东西南北坐标量偏移

接下来是连通块合并，

void Union(int X,int Y,int L,char D){
	int root1=Find(X),root2=Find(Y);
	if(root1!=root2){
		f[root1].pre=root2;
		if(D=='W'||D=='E'){
			if(D=='W')L=-L;
			f[root1].w0=f[Y].w0+L-f[X].w0;
			f[root1].w1=f[Y].w1-f[X].w1;
		}else {
			if(D=='S')L=-L;
			f[root1].w0=f[Y].w0-f[X].w0;
			f[root1].w1=f[Y].w1+L-f[X].w1;
		}
	}
}

下图为详细图解，南北方向可以自己推一下，注意相对方向，我这里是取了向北和向东为正

下面是完整代码

#include<vector>
#include<cstring>
#include<cstdio>
#include<iostream>
#include<string>
#include<map>
#include<queue>
#include<algorithm>
#include<ctime>
#include<cmath>
#include<cstdlib>
#define lson (o<<1)
#define rson (o<<1|1)
#define fi first
#define sc second
#define dbg(x) cout<<#x<<" = "<<(x)<<endl;
#define rg register
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
using namespace std;
const double pi=acos(-1);
const double eps=1e-6;
inline int lowbit(int x){return x&(-x);}

template<typename A,typename B,typename C> inline A fpow(A x,B p,C yql){
	A ans=1;
	for(;p;p>>=1,x=1LL*x*x%yql)if(p&1)ans=1LL*x*ans%yql;
	return ans;
}


inline int read()
{
    int X=0,w=1;
    char c=getchar();
    while(c<'0'||c>'9')
    {
        if (c=='-')
        {
            w=-1;
        }
        c=getchar();
    }
    while(c>='0'&&c<='9')
    {
        X=(X<<3)+(X<<1)+(c^48);
        c=getchar();
    }
    return X*w;
}
//inline void w(int x) { if(x>9) w(x/10); putchar(x%10+'0'); }

int T,N,M,K;

struct F{
	int pre,w1,w0;
}f[40005];

struct Road{
	int x,y,l;
	char d;
}road[40005];

struct Query{
	int t,x,y;
}Q[40005];

int Find(int x){
	if(f[x].pre==x)return x;
	int t=f[x].pre;
	f[x].pre=Find(f[x].pre);
	f[x].w0+=f[t].w0;
	f[x].w1+=f[t].w1;
	return f[x].pre;
}

void Union(int X,int Y,int L,char D){
	int root1=Find(X),root2=Find(Y);
	if(root1!=root2){
		f[root1].pre=root2;
		if(D=='W'||D=='E'){
			if(D=='W')L=-L;
			f[root1].w0=f[Y].w0+L-f[X].w0;
			f[root1].w1=f[Y].w1-f[X].w1;
		}else {
			if(D=='S')L=-L;
			f[root1].w0=f[Y].w0-f[X].w0;
			f[root1].w1=f[Y].w1+L-f[X].w1;
		}
	}
}

void solve(){
	cin>>N>>M;
	for(int i=1;i<=N;i++){
		f[i].pre=i;
		f[i].w0=0;
		f[i].w1=0;
	}
	for(int i=1;i<=M;i++){
		cin>>road[i].x>>road[i].y>>road[i].l>>road[i].d;
	}
	
	cin>>K;
	
	for(int i=1;i<=K;i++){
		cin>>Q[i].x>>Q[i].y>>Q[i].t;
	}
	Q[0].t=0;
	for(int i=1;i<=K;i++){
		
		for(int j=Q[i-1].t;j<=Q[i].t;j++){
			Union(road[j].x,road[j].y,road[j].l,road[j].d);
		}
		int root1=Find(Q[i].x),root2=Find(Q[i].y);
		if(root1!=root2){
			cout<<"-1"<<endl;
		}else {
			cout<<abs(f[Q[i].x].w0-f[Q[i].y].w0)+abs(f[Q[i].x].w1-f[Q[i].y].w1)<<endl;
		}
	}
	
}


int main(){
	std::ios::sync_with_stdio(0);
	std::cin.tie(0);
	T=1;
	//cin>>T;
	while(T--){
		solve();
	}
	return 0;
}