Corporative Network (有n个节点，然后执行I u，v（把u的父节点设为v）和E u（询问u到根节点的距离）)并查集

A very big corporation is developing its corporative network. In the beginning each of the N enterprises of the
corporation, numerated from 1 to N, organized its own computing and telecommunication center. Soon, for
amelioration of the services, the corporation started to collect some enterprises in clusters, each of them
served by a single computing and telecommunication center as follow. The corporation chose one of the
existing centers I (serving the cluster A) and one of the enterprises J in some cluster B (not necessarily the
center) and link them with telecommunication line. The length of the line between the enterprises I and J is |I
 J|(mod 1000). In such a way the two old clusters are joined in a new cluster, served by the center of the old
cluster B. Unfortunately after each join the sum of the lengths of the lines linking an enterprise to its serving
center could be changed and the end users would like to know what is the new length. Write a program to
keep trace of the changes in the organization of the network that is able in each moment to answer the
questions of the users.
Input 
Your program has to be ready to solve more than one test case. The first line of the input file will contains
only the number T of the test cases. Each test will start with the number N of enterprises (5≤N≤20000). Then
some number of lines (no more than 200000) will follow with one of the commands:
E I  asking the length of the path from the enterprise I to its serving center in the moment;
I I J  informing that the serving center I is linked to the enterprise J.
The test case finishes with a line containing the word O. The I commands are less than N.
Output 
The output should contain as many lines as the number of E commands in all test cases with a single number
each  the asked sum of length of lines connecting the corresponding enterprise with its serving center.
Sample Input 
1
4
E 3
I 3 1
E 3
I 1 2
E 3
I 2 4
E 3
O
Sample Output 
0
2
3
5

　　　题意是： 有n个节点，然后执行I u，v（把u的父节点设为v）和E u（询问u到根节点的距离。

　　　I ： u v   将u的父节点变为v。

　　　 E：u   输出u到根节点的距离

　　　这是一个带权的并查集。而对这个题而言，输入I后，某点的父节点是不断在变的，如果本来1的父节点是3，我输入“I 1 5”,那么1的父节点就变成5了，距离是4而不是2。所以输入I以后，我们只需要执行这些代码：

else if(ch=='I')
            {
                ll a,b;cin>>a>>b;
                pr[a]=b;　　　　//更新父节点
　　　　　　　　　　dis[a]=abs(b-a)%;　　//更新距离
            }

　  　而输入“E”后，我们需要执行find（u），找出u的根节点的过程中，更新dis的值，找到根节点后，要把，pr【x】=f。更新好其根节点。

　　如果不明白的话，可以拿此样例操作一遍就理解了：

　　I  1 2

　　I  2 3

　　I  1 4

　　E 1

　　代码：

　　

#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<cmath>
using namespace std;
const int maxn=;
typedef long long ll;
ll pr[maxn];
ll dis[maxn];
int find(ll x)
{
    if(pr[x]!=x)
    {
        ll f=find(pr[x]);
        dis[x]+=dis[pr[x]];
        return pr[x]=f;　　//否则会出现dis重复加的情况，即每次询问都要加一遍，会越来越大。
    }
    else
        return x;
}
int main()
{
    ll t;
    cin>>t;
    while(t--)
    {
        ll n;
        cin>>n;
        for(int i=;i<maxn;i++)
        {
            pr[i]=i;dis[i]=;
        }
        char ch;
        while(cin>>ch)
        {
            if(ch=='')
                break;
            else if(ch=='I')
            {
                ll a,b;cin>>a>>b;
                pr[a]=b;dis[a]=abs(b-a)%;
            }
            else if(ch=='E')
            {
                ll a;
                cin>>a;
                find(a);
                cout<<dis[a]<<endl;
            }
        }
    }
    return ;
}