BZOJ3510首都（LCT）

Description

在X星球上有N个国家，每个国家占据着X星球的一座城市。由于国家之间是敌对关系，所以不同国家的两个城市是不会有公路相连的。
X星球上战乱频发，如果A国打败了B国，那么B国将永远从这个星球消失，而B国的国土也将归A国管辖。A国国王为了加强统治，会在A国和B国之间修建一条公路，即选择原A国的某个城市和B国某个城市，修建一条连接这两座城市的公路。
同样为了便于统治自己的国家，国家的首都会选在某个使得其他城市到它距离之和最小的城市，这里的距离是指需要经过公路的条数，如果有多个这样的城市，编号最小的将成为首都。
现在告诉你发生在X星球的战事，需要你处理一些关于国家首都的信息，具体地，有如下3种信息需要处理：
1、A x y：表示某两个国家发生战乱，战胜国选择了x城市和y城市，在它们之间修建公路（保证其中城市一个在战胜国另一个在战败国）。
2、Q x：询问当前编号为x的城市所在国家的首都。
3、Xor：询问当前所有国家首都编号的异或和。

Input

第一行是整数N，M，表示城市数和需要处理的信息数。
接下来每行是一个信息，格式如题目描述（A、Q、Xor中的某一种）。

Output

输出包含若干行，为处理Q和Xor信息的结果。

Sample Input

10 10
Xor
Q 1
A 10 1
A 1 4
Q 4
Q 10
A 7 6
Xor
Q 7
Xor

Sample Output

11
1
1
1
2
6
2

解题思路：

主要是动态维护重心。

可以证明，新的中心在原来两个树中心路径上。

那么就把这段路径提取出来找就好了。

注意将重心旋转至根，保证时间复杂度。

代码：

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #define lll tr[spc].ch[0]
 #define rrr tr[spc].ch[1]
 #define ls ch[0]
 #define rs ch[1]
 struct trnt{
     int ch[];
     int fa;
     int lzt;
     int wgt;
     int wgti;
     int ff;
     bool anc;
 }tr[];
 int st[];
 int tp;
 int n,m;
 int Xorsum;
 char cmd[];
 bool whc(int spc)
 {
     return tr[tr[spc].fa].rs==spc;
 }
 int finf(int x)
 {
     return tr[x].ff==x?x:tr[x].ff=finf(tr[x].ff);
 }
 void pushup(int spc)
 {
     if(!spc)
         return ;
     tr[spc].wgt=tr[spc].wgti+tr[lll].wgt+tr[rrr].wgt+;
     return ;
 }
 void trr(int spc)
 {
     if(!spc)
         return;
     std::swap(lll,rrr);
     tr[spc].lzt^=;
     return ;
 }
 void pushdown(int spc)
 {
     if(tr[spc].lzt)
     {
         trr(lll);
         trr(rrr);
         tr[spc].lzt=;
     }
     return ;
 }
 void recal(int spc)
 {
     if(!tr[spc].anc)
         recal(tr[spc].fa);
     pushdown(spc);
     return ;
 }
 void rotate(int spc)
 {
     int f=tr[spc].fa;
     bool k=whc(spc);
     tr[f].ch[k]=tr[spc].ch[!k];
     tr[spc].ch[!k]=f;
     if(tr[f].anc)
     {
         tr[spc].anc=;
         tr[f].anc=;
     }else
         tr[tr[f].fa].ch[whc(f)]=spc;
     tr[spc].fa=tr[f].fa;
     tr[f].fa=spc;
     tr[tr[f].ch[k]].fa=f;
     pushup(f);
     pushup(spc);
     return ;
 }
 void splay(int spc)
 {
     recal(spc);
     while(!tr[spc].anc)
     {
         int f=tr[spc].fa;
         if(tr[f].anc)
         {
             rotate(spc);
             break;
         }
         if(whc(spc)^whc(f))
             rotate(spc);
         else
             rotate(f);
         rotate(spc);
     }
     return ;
 }
 void access(int spc)
 {
     int lst=;
     while(spc)
     {
         splay(spc);
         tr[spc].wgti+=tr[rrr].wgt;
         tr[spc].wgti-=tr[lst].wgt;
         tr[rrr].anc=;
         tr[lst].anc=;
         rrr=lst;
         pushup(spc);
         lst=spc;
         spc=tr[spc].fa;
     }
     return ;
 }
 void Mtr(int spc)
 {
     access(spc);
     splay(spc);
     trr(spc);
     return ;
 }
 void split(int x,int y)
 {
     Mtr(x);
     access(y);
     splay(y);
     return ;
 }
 void link(int x,int y)
 {
     split(x,y);
     tr[x].fa=y;
     tr[y].wgti+=tr[x].wgt;
     pushup(y);
     return ;
 }
 int Gravity(int spc)
 {
     int lwgt=;
     int rwgt=;
     int tot=tr[spc].wgt/;
     int odd=tr[spc].wgt&;
     int ans=0x3f3f3f3f;
     while(spc)
     {
         pushdown(spc);
         int ll,rr;
         ll=lwgt+tr[lll].wgt;
         rr=rwgt+tr[rrr].wgt;
         if(ll<=tot&&rr<=tot)
         {
             if(odd)
             {
                 ans=spc;
                 break;
             }
             if(ans>spc)
                 ans=spc;
         }
         if(ll>rr)
         {
             rwgt+=(tr[spc].wgti+tr[rrr].wgt+);
             spc=lll;
         }else{
             lwgt+=(tr[spc].wgti+tr[lll].wgt+);
             spc=rrr;
         }
     }
     splay(ans);
     return ans;
 }
 int main()
 {
     scanf("%d%d",&n,&m);
     for(int i=;i<=n;i++)
     {
         tr[i].wgt=tr[i].anc=;
         tr[i].ff=i;
         Xorsum^=i;
     }
     while(m--)
     {
         scanf("%s",cmd);
         if(cmd[]=='A')
         {
             int x,y;
             scanf("%d%d",&x,&y);
             link(x,y);
             x=finf(x);
             y=finf(y);
             split(x,y);
             int g=Gravity(y);
             Xorsum=Xorsum^x^y^g;
             tr[x].ff=tr[y].ff=tr[g].ff=g;
         }
         if(cmd[]=='Q')
         {
             int x;
             scanf("%d",&x);
             printf("%d\n",finf(x));
         }
         if(cmd[]=='X')
         {
             printf("%d\n",Xorsum);
         }
     }
     return ;
 }