Bzoj3510首都

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <cmath>
 #include <algorithm>
 #define maxn 100005
 #define maxm 400005
 using namespace std;

 int n,m,ans,vis[maxn],head,tot,now[maxn],prep[maxm],son_[maxm],fa[maxn],son[maxn][],size[maxn],add[maxn],list[maxn],tail;
 bool rev[maxn];

 bool which(int x){
     return son[fa[x]][]==x;
 }

 bool isroot(int x){
     return son[fa[x]][]!=x&&son[fa[x]][]!=x;
 }

 void insert_(int x,int y){
     size[x]+=y,add[x]+=y;
 }

 void pushdown(int x){
     if (!x) return;
     if (rev[x]){
         rev[x]^=,swap(son[x][],son[x][]);
         if (son[x][]) rev[son[x][]]^=;
         if (son[x][]) rev[son[x][]]^=;
     }
     if (add[x]){
         if (son[x][]) insert_(son[x][],add[x]);
         if (son[x][]) insert_(son[x][],add[x]);
         add[x]=;
     }
 }

 void relax(int x){
     if (!isroot(x)) relax(fa[x]);
     pushdown(x);
 }

 void rotata(int x){
     int y=fa[x],d=which(x),dd=which(y);
     if (!isroot(y)) son[fa[y]][dd]=x; fa[x]=fa[y];
     fa[son[x][d^]]=y,son[y][d]=son[x][d^];
     fa[y]=x,son[x][d^]=y;
 }

 void splay(int x){
     relax(x);
     while (!isroot(x)){
         if (isroot(fa[x])) rotata(x);
         else if (which(x)==which(fa[x])) rotata(fa[x]),rotata(x);
         else rotata(x),rotata(x);
     }
 }

 void access(int x){
     for (int p=;x;x=fa[x]){
         splay(x);
         son[x][]=p;
         p=x;
     }
 }

 int succ(int x){
     splay(x);
     int y=son[x][];
     for (pushdown(y);son[y][];y=son[y][],pushdown(y));
     return y;
 }

 int find_root(int x){
     access(x);
     splay(x);
     while (son[x][]) x=son[x][];
     return x;
 }

 void insert(int x,int y){
     tot++,prep[tot]=now[x],now[x]=tot,son_[tot]=y;
 }

 void bfs(int x,int y){
     int t;
     head=,tail=,list[]=y,size[y]=,fa[y]=son[y][]=son[y][]=,vis[y]=m,add[y]=rev[y]=;
     while (head<tail){
         head++,t=list[head];
         for (int i=now[t],so=son_[i];i;i=prep[i],so=son_[i]){
             if (vis[so]!=m){
                 vis[so]=m,size[so]=,fa[so]=son[so][]=son[so][]=add[so]=rev[so]=,fa[so]=t;
                 list[++tail]=so;
             }
         }
     }
     for (int i=tail;i>=;i--){
         t=list[i];
         if (fa[t]) size[fa[t]]+=size[t];
     }
 }

 void make_root(int x){
     access(x);
     splay(x);
     rev[x]^=;
 }

 void merge(int x,int y){
     int rx,ry,t;
     rx=find_root(x),ry=find_root(y);
     if (rx==ry) return;
     if (size[rx]<size[ry]) swap(x,y),swap(rx,ry);
     ans^=ry;
     bfs(x,y),insert(x,y),insert(y,x),fa[y]=x;
     access(x),splay(x),insert_(x,size[y]);
 //    access(ry),splay(rx),relax(ry);
     access(ry);
     for (;;){
         t=succ(rx);
         if (!t){
             make_root(rx);
             break;
         }
         if (size[t]*>size[rx]||(size[t]*==size[rx]&&t<rx)){
 //            son[t][0]=0;
             swap(size[t],size[rx]),size[rx]=size[t]-size[rx];
             ans^=rx,ans^=t,rx=t;
         }else{
             make_root(rx);
             break;
         }
     }
 }

 int main(){
     freopen("capital.in","r",stdin);
     freopen("capital.out","w",stdout);
     char st[];
     int u,v;
     memset(vis,-,sizeof(vis));
     scanf("%d%d",&n,&m),ans=;
     tot=,memset(now,,sizeof(now));
     memset(rev,,sizeof(rev));
     memset(size,,sizeof(size));
     for (int i=;i<=n;i++) add[i]=fa[i]=son[i][]=son[i][]=,size[i]=;
     for (int i=;i<=n;i++) ans^=i;
     while (m--){
         scanf("%s",st+);
         if (st[]=='X') printf("%d\n",ans);
         else if (st[]=='Q') scanf("%d",&u),printf("%d\n",find_root(u));
         else scanf("%d%d",&u,&v),merge(u,v);
     }
     return ;
 }

题目链接：http://www.lydsy.com/JudgeOnline/problem.php?id=3510

题意：一个森林，要求维护每棵树的重心（多个重心取编号最小的那个），支持三个操作：

1．          连接两个节点（保证两个节点不在同一棵树中）。

2．          询问某个节点所在树的重心。

3．          询问所有树的重心编号的异或和。

关于重心有几个性质：

1. 以重心为根，任意一个子树的节点个数<=总结点数/2，否则重心可向该子树方向转移。
2. 设树中节点x的权值为该点到树中每个点的距离之和，则重心的权值最小。
3. 两个树合并为一颗新树后，新树的重心一定在原来的两个重心之间唯一的路径上。

做法：考虑用lct动态维护树的重心，以原树中的重心做为原树根，

由于只有合并操作（合并节点x和y，sizex>sizey），可以考虑启发式合并，即把节点数少的那棵树（y所在树）暴力重建（一次BFS），接到另一棵树（x所在树）上，节点y所在树上的信息可在bfs过程中维护好，节点x所在的树的size信息会有什么变化呢，我们发现节点x到原x树重心的路径上size[i]会加上y树的总结点数，这就是用lct的缘故。接下来我们考虑如何维护新树的重心，并作为新树的根呢？根据重心的性质3，我们考虑暴力转移重心，由于是启发式合并，据说复杂度可靠，我们将原来的两个重心的路径放到同一棵splay中来，从x树中重心开始暴力转移，如果节点p的后继节点q，若(sizeq*2>sizep)or（sizeq*2=sizep&&q<p），则将重心从p转移至q点，最后将make_root(新重心)，操作1得以解决。

对于操作2，用lct求该节点所在树的根即可，因为树根为重心。

对于操作3， 用ans维护即可，每次更新重心更新时更新ans。

Lct动态维护树的重心（Lct+启发式合并+暴力转移重心）。