HDU 2475 Box

Box

Time Limit: 5000ms

Memory Limit: 32768KB

This problem will be judged on HDU. Original ID: 2475
64-bit integer IO format: %I64d      Java class name: Main

There are N boxes on the ground, which are labeled by numbers from 1 to N. The boxes are magical, the size of each one can be enlarged or reduced arbitrarily.
Jack can perform the “MOVE x y” operation to the boxes: take out box x; if y = 0, put it on the ground; Otherwise, put it inside box y. All the boxes inside box x remain the same. It is possible that an operation is illegal, that is, if box y is contained (directly or indirectly) by box x, or if y is equal to x.
In the following picture, box 2 and 4 are directly inside box 6, box 3 is directly inside box 4, box 5 is directly inside box 1, box 1 and 6 are on the ground.

The picture below shows the state after Jack performs “MOVE 4 1”:

Then he performs “MOVE 3 0”, the state becomes:

During a sequence of MOVE operations, Jack wants to know the root box of a specified box. The root box of box x is defined as the most outside box which contains box x. In the last picture, the root box of box 5 is box 1, and box 3’s root box is itself.

 

Input

Input contains several test cases.
For each test case, the first line has an integer N (1 <= N <= 50000), representing the number of boxes.
Next line has N integers: a1, a2, a3, ... , aN (0 <= ai <= N), describing the initial state of the boxes. If ai is 0, box i is on the ground, it is not contained by any box; Otherwise, box i is directly inside box ai. It is guaranteed that the input state is always correct (No loop exists).
Next line has an integer M (1 <= M <= 100000), representing the number of MOVE operations and queries.
On the next M lines, each line contains a MOVE operation or a query:
1.  MOVE x y, 1 <= x <= N, 0 <= y <= N, which is described above. If an operation is illegal, just ignore it.
2.  QUERY x, 1 <= x <= N, output the root box of box x.

 

Output

For each query, output the result on a single line. Use a blank line to separate each test case.

 

Sample Input

2
0 1
5
QUERY 1
QUERY 2
MOVE 2 0
MOVE 1 2
QUERY 1
6
0 6 4 6 1 0
4
MOVE 4 1
QUERY 3
MOVE 1 4
QUERY 1

Sample Output

1
1
2

1
1

Source

2008 Asia Regional Chengdu

 

解题：Link-Cut tree

 #include <bits/stdc++.h>
 using namespace std;
 const int maxn = ;
 struct LCT{
     int fa[maxn],ch[maxn][],parent[maxn];
     void init(){
         memset(fa,,sizeof fa);
         memset(ch,,sizeof ch);
     }
     void rotate(int x,int kd){
         int y = fa[x];
         ch[y][kd^] = ch[x][kd];
         fa[ch[x][kd]] = y;
         fa[x] = fa[y];
         ch[x][kd] = y;
         fa[y] = x;
         if(fa[x]) ch[fa[x]][y == ch[fa[x]][]] = x;
     }
     void splay(int x,int goal = ){
         int y = x;
         while(fa[y]) y = fa[y];
         if(x != y){
             parent[x] = parent[y];
             parent[y] = ;
             while(fa[x] != goal){
                 if(fa[fa[x]] == goal) rotate(x,x == ch[fa[x]][]);
                 else{
                     int y = fa[x],z = fa[y],s = (y == ch[z][]);
                     if(x == ch[y][s]){
                         rotate(x,s^);
                         rotate(x,s);
                     }else{
                         rotate(y,s);
                         rotate(x,s);
                     }
                 }
             }
         }
     }
     void access(int x){
         for(int y = ; x; x = parent[x]){
             splay(x);
             fa[ch[x][]] = ;
             parent[ch[x][]] = x;
             ch[x][] = y;
             fa[y] = x;
             parent[y] = ;
             y = x;
         }
     }
     int GetRoot(int x){
         access(x);
         splay(x);
         while(ch[x][]) x = ch[x][];
         return x;
     }
     void cut(int x){
         access(x);
         splay(x);
         parent[ch[x][]] = parent[x];
         parent[x] = ;
         fa[ch[x][]] = ;
         ch[x][] = ;
     }
     void join(int x,int y){
         if(!y) cut(x);
         else{
             access(y);
             splay(y);
             int z = x;
             while(fa[z]) z = fa[z];
             if(z != y){
                 cut(x);
                 parent[x] = y;
             }
         }
     }
 }lct;
 int main(){
     int n,m,u,v;
     char op[];
     bool flag = false;
     while(~scanf("%d",&n)){
         lct.init();
         if(flag) putchar('\n');
         for(int i = ; i <= n; ++i)
             scanf("%d",&lct.parent[i]);
         scanf("%d",&m);
         while(m--){
             scanf("%s%d",op,&u);
             if(op[] == 'Q') printf("%d\n",lct.GetRoot(u));
             else{
                 scanf("%d",&v);
                 lct.join(u,v);
             }
         }
         flag = true;
     }
     return ;
 }