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 = 300010;
struct LCT{
    int fa[maxn],ch[maxn][2],parent[maxn];
    void init(){
        memset(fa,0,sizeof fa);
        memset(ch,0,sizeof ch);
    }
    void rotate(int x,int kd){
        int y = fa[x];
        ch[y][kd^1] = 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]][1]] = x;
    }
    void splay(int x,int goal = 0){
        int y = x;
        while(fa[y]) y = fa[y];
        if(x != y){
            parent[x] = parent[y];
            parent[y] = 0;
            while(fa[x] != goal){
                if(fa[fa[x]] == goal) rotate(x,x == ch[fa[x]][0]);
                else{
                    int y = fa[x],z = fa[y],s = (y == ch[z][0]);
                    if(x == ch[y][s]){
                        rotate(x,s^1);
                        rotate(x,s);
                    }else{
                        rotate(y,s);
                        rotate(x,s);
                    }
                }
            }
        }
    }
    void access(int x){
        for(int y = 0; x; x = parent[x]){
            splay(x);
            fa[ch[x][1]] = 0;
            parent[ch[x][1]] = x;
            ch[x][1] = y;
            fa[y] = x;
            parent[y] = 0;
            y = x;
        }
    }
    int GetRoot(int x){
        access(x);
        splay(x);
        while(ch[x][0]) x = ch[x][0];
        return x;
    }
    void cut(int x){
        access(x);
        splay(x);
        parent[ch[x][0]] = parent[x];
        parent[x] = 0;
        fa[ch[x][0]] = 0;
        ch[x][0] = 0;
    }
    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[10];
    bool flag = false;
    while(~scanf("%d",&n)){
        lct.init();
        if(flag) putchar('\n');
        for(int i = 1; i <= n; ++i)
            scanf("%d",&lct.parent[i]);
        scanf("%d",&m);
        while(m--){
            scanf("%s%d",op,&u);
            if(op[0] == 'Q') printf("%d\n",lct.GetRoot(u));
            else{
                scanf("%d",&v);
                lct.join(u,v);
            }
        }
        flag = true;
    }
    return 0;
}