【bzoj 3779】重组病毒

Description

黑客们通过对已有的病毒反编译，将许多不同的病毒重组，并重新编译出了新型的重组病毒。这种病毒的繁殖和变异能力极强。为了阻止这种病毒传播，某安全机构策划了一次实验，来研究这种病毒。
实验在一个封闭的局域网内进行。局域网内有n台计算机，编号为1~n。一些计算机之间通过网线直接相连，形成树形的结构。局域网中有一台特殊的计算机，称之为核心计算机。根据一些初步的研究，研究员们拟定了一个一共m步的实验。实验开始之前，核心计算机的编号为1，每台计算机中都有病毒的一个变种，而且每台计算机中的变种都不相同。实验中的每一步会是下面中的一种操作：
1、 RELEASE x
在编号为x的计算机中植入病毒的一个新变种。这个变种在植入之前不存在于局域网中。
2、 RECENTER x
将核心计算机改为编号为x的计算机。但是这个操作会导致原来核心计算机中的病毒产生新变种，并感染过来。换言之，假设操作前的核心计算机编号为y，相当于在操作后附加了一次RELEASE y的操作。
根据研究的结论，在植入一个新变种时，病毒会在局域网中搜索核心计算机的位置，并沿着网络中最短的路径感染过去。
而第一轮实验揭露了一个惊人的真相：病毒的不同变种是互斥的。新变种在感染一台已经被旧变种感染的电脑时，会把旧变种完全销毁之后再感染。但研究员发现了实现过程中的漏洞。如果新变种在感染过程中尚未销毁过这类旧变种，需要先花费1单位时间分析旧变种，才能销毁。如果之前销毁过这类旧变种，就可以认为销毁不花费时间。病毒在两台计算机之间的传播亦可认为不花费时间。
研究员对整个感染过程的耗时特别感兴趣，因为这是消灭病毒的最好时机。于是在m步实验之中，研究员有时还会做出如下的询问：
3、 REQUEST x
询问如果在编号为x的计算机的关键集合中的计算机中植入一个新变种，平均感染时间为多长。编号为y的计算机在编号为x的计算机的关键集合中，当且仅当从y沿网络中的最短路径感染到核心计算机必须经过x。由于有RECENTER操作的存在，这个集合并不一定是始终不变的。
至此，安全机构认为已经不需要实际的实验了，于是他们拜托你编写一个程序，模拟实验的结果，并回答所有的询问。

Input

输入的第一行包含两个整数n和m，分别代表局域网中计算机的数量，以及操作和询问的总数。
接下来n-1行，每行包含两个整数x和y，表示局域网中编号为x和y的计算机之间有网线直接相连。
接下来m行，每行包含一个操作或者询问，格式如问题描述中所述。

Output

对于每个询问，输出一个实数，代表平均感染时间。输出与答案的绝对误差不超过 10^(-6)时才会被视为正确。

Sample Input

8 6
1 2
1 3
2 8
3 4
3 5
3 6
4 7
REQUEST 7
RELEASE 3
REQUEST 3
RECENTER 5
RELEASE 2
REQUEST 1

Sample Output

4.0000000000
2.0000000000
1.3333333333

HINT

N<=100000 ，M<=100000

调了几个世纪终于调出来了……LCT+dfs序线段树。

令每个点权值为这个点到根的路径上虚边数+1，一开始时都是虚边，点权即为深度。

操作1可以神转换为access。在access过程中，当前节点的右儿子所代表的子树整体权值+1（因为虚边+1），而即将拼接过来的子树整体权值-1。

操作2因为有换根操作，所以需要分类讨论一波（以下结论画图易得）：

1. x=root，查询整棵树；

2. root不在x的子树内，查询原树中x的子树；

3. root在x的子树内，查询整棵树去除掉包含root的以x的亲儿子为根的子树。

然后就可以开始瞎搞啦✔

Update：原来的代码有一点问题……重新写了一份。

 #include<cstdio>
 #include<algorithm>
 #include<cstring>
 #define LL long long
 #define lc(x) x<<1
 #define rc(x) x<<1|1
 using namespace std;
 const int N=1e5+;
 int n,m,x,y,cnt,dfn,rt=,first[N];
 int deep[N],in[N],out[N],fa[N][];
 char op[];
 int read()
 {
     int x=,f=;char c=getchar();
     while(c<''||c>''){if(c=='-')f=-;c=getchar();}
     while(c>=''&&c<=''){x=x*+c-'';c=getchar();}
     return x*f;
 }
 struct edge{int to,next;}e[N<<];
 void ins(int u,int v){e[++cnt]=(edge){v,first[u]};first[u]=cnt;}
 struct SGT
 {
     int l[N*],r[N*];
     LL sum[N*],tag[N*];
     void build(int x,int L,int R)
     {
         l[x]=L;r[x]=R;if(L==R)return;
         int mid=(L+R)>>;
         build(lc(x),L,mid);build(rc(x),mid+,R);
     }
     void up(int x){sum[x]=sum[lc(x)]+sum[rc(x)];}
     void qadd(int x,LL w){tag[x]+=w;sum[x]+=w*(r[x]-l[x]+);}
     void down(int x)
     {
         if(!tag[x])return;
         qadd(lc(x),tag[x]);qadd(rc(x),tag[x]);
         tag[x]=;
     }
     void add(int x,int L,int R,LL w)
     {
         if(L<=l[x]&&r[x]<=R){qadd(x,w);return;}
         down(x);int mid=(l[x]+r[x])>>;
         if(L<=mid)add(lc(x),L,R,w);
         if(R>mid)add(rc(x),L,R,w);
         up(x);
     }
     LL query(int x,int L,int R)
     {
         if(L<=l[x]&&r[x]<=R)return sum[x];
         down(x);LL ans=;
         int mid=(l[x]+r[x])>>;
         if(L<=mid)ans+=query(lc(x),L,R);
         if(R>mid)ans+=query(rc(x),L,R);
         return ans;
     }
 }sgt;
 int find(int x,int y)
 {
     int d=deep[y]-deep[x]-;
     for(int i=;i>=;i--)
         if(d&(<<i))y=fa[y][i];
     return y;
 }
 void addson(int x,LL w)
 {
     if(x==rt)sgt.add(,,n,w);
     else if(in[rt]>=in[x]&&out[rt]<=out[x])
     {
         int t=find(x,rt);
         if(in[t]>)sgt.add(,,in[t]-,w);
         if(out[t]<n)sgt.add(,out[t]+,n,w);
     }
     else sgt.add(,in[x],out[x],w);
 }
 struct LCT
 {
     int c[N][],fa[N],in[N],out[N];
     bool rev[N];
     bool isroot(int x){return c[fa[x]][]!=x&&c[fa[x]][]!=x;}
     void flip(int x){swap(c[x][],c[x][]);rev[x]^=;}
     void down(int x){if(rev[x])flip(c[x][]),flip(c[x][]),rev[x]=;}
     void rotate(int x)
     {
         int y=fa[x],z=fa[y],l,r;
         if(c[y][]==x)l=;else l=;r=l^;
         if(!isroot(y)){if(c[z][]==y)c[z][]=x;else c[z][]=x;}
         fa[x]=z;fa[y]=x;fa[c[x][r]]=y;
         c[y][l]=c[x][r];c[x][r]=y;
     }
     void relax(int x){if(!isroot(x))relax(fa[x]);down(x);}
     void splay(int x)
     {
         relax(x);
         while(!isroot(x))
         {
             int y=fa[x],z=fa[y];
             if(!isroot(y))
             {
                 if((c[y][]==x)^(c[z][]==y))rotate(x);
                 else rotate(y);
             }
             rotate(x);
         }
     }
     int top(int x){down(x);while(c[x][])x=c[x][],down(x);return x;}
     void access(int x)
     {
         int t=;
         while(x)
         {
             splay(x);
             if(c[x][])addson(top(c[x][]),);
             if(t)addson(top(t),-);
             c[x][]=t;t=x;x=fa[x];
         }
     }
     void makeroot(int x){splay(x);rt=x;flip(x);}
 }lct;
 void dfs(int x)
 {
     in[x]=++dfn;
     sgt.add(,in[x],in[x],deep[x]);
     for(int i=;(<<i)<=deep[x];i++)
         fa[x][i]=fa[fa[x][i-]][i-];
     for(int i=first[x];i;i=e[i].next)
     {
         int to=e[i].to;
         if(to==fa[x][])continue;
         fa[to][]=lct.fa[to]=x;
         deep[to]=deep[x]+;dfs(to);
     }
     out[x]=dfn;
 }
 double request(int x)
 {
     if(x==rt)return 1.0*sgt.query(,,n)/n;
     if(in[rt]>=in[x]&&out[rt]<=out[x])
     {
         int t=find(x,rt);LL sum=;
         if(in[t]>)sum+=sgt.query(,,in[t]-);
         if(out[t]<n)sum+=sgt.query(,out[t]+,n);
         return 1.0*sum/(n-(out[t]-in[t]+));
     }
     return 1.0*sgt.query(,in[x],out[x])/(out[x]-in[x]+);
 }
 int main()
 {
     n=read();m=read();
     for(int i=;i<n;i++)x=read(),y=read(),ins(x,y),ins(y,x);
     sgt.build(,,n);deep[]=;dfs();
     while(m--)
     {
         scanf("%s",op);x=read();
         if(op[]=='Q')printf("%.10lf\n",request(x));
         else
         {
             lct.access(x);
             if(op[]=='C')lct.makeroot(x);
         }
     }
     return ;
 }