CodeForcesGym 100512D Dynamic LCA

Dynamic LCA

Time Limit: 2000ms

Memory Limit: 262144KB

This problem will be judged on CodeForcesGym. Original ID: 100512D
64-bit integer IO format: %I64d      Java class name: (Any)

解题：LCT

 #include <bits/stdc++.h>
 using namespace std;
 const int maxn = ;
 struct arc {
     int to,next;
     arc(int x = ,int y = -) {
         to = x;
         next = y;
     }
 } e[maxn<<];
 int head[maxn],tot;
 void add(int u,int v) {
     e[tot] = arc(v,head[u]);
     head[u] = tot++;
 }
 struct LCT {
     int fa[maxn],ch[maxn][],parent[maxn],flip[maxn];
     inline void pushdown(int x) {
         if(flip[x]) {
             flip[ch[x][]] ^= ;
             flip[ch[x][]] ^= ;
             swap(ch[x][],ch[x][]);
             flip[x] = ;
         }
     }
     void build(int u,int v) {
         fa[v] = ch[v][] = ch[v][] = ;
         flip[v] = ;
         parent[v] = u;
     }
     void rotate(int x,int kd) {
         int y = fa[x];
         pushdown(y);
         pushdown(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];
         pushdown(x);
         if(x != y) {
             parent[x] = parent[y];
             parent[y] = ;
             while(fa[x] != goal) {
                 pushdown(fa[fa[x]]);
                 pushdown(fa[x]);
                 pushdown(x);
                 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 LCA(int x,int y) {
         access(y);
         splay(y);
         for(int z = x; z; z = parent[z]) {
             splay(z);
             if(!parent[z]) return z;
         }
         return -;
     }
     void makeroot(int x) {
         access(x);
         splay(x);
         flip[x] ^= ;
     }
     void init(){
         memset(flip,,sizeof flip);
         memset(ch,,sizeof ch);
         memset(parent,,sizeof parent);
         memset(fa,,sizeof fa);
     }
 } lct;
 void dfs(int u,int fa) {
     for(int i = head[u]; ~i; i = e[i].next) {
         if(e[i].to == fa) continue;
         lct.build(u,e[i].to);
         dfs(e[i].to,u);
     }
 }
 int main() {
 #define NAME "dynamic"
     freopen(NAME".in","r",stdin);
     freopen(NAME".out","w",stdout);
     int n,m,u,v;
     char op[];
     while(scanf("%d",&n),n) {
         memset(head,-,sizeof head);
         tot = ;
         lct.init();
         for(int i = ; i < n; ++i) {
             scanf("%d%d",&u,&v);
             add(u,v);
             add(v,u);
         }
         lct.build(,);
         dfs(,);
         scanf("%d",&m);
         while(m--) {
             scanf("%s%d",op,&u);
             if(op[] == '!') lct.makeroot(u);
             else if(op[] == '?') {
                 scanf("%d",&v);
                 printf("%d\n",lct.LCA(u,v));
             }
         }
     }
     return ;
 }
 /*
 9
 1 2
 1 3
 2 4
 2 5
 3 6
 3 7
 6 8
 6 9
 10
 ? 4 5
 ? 5 6
 */