【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+5;
int n,m,x,y,cnt,dfn,rt=1,first[N];
int deep[N],in[N],out[N],fa[N][18];
char op[15];
int read()
{
    int x=0,f=1;char c=getchar();
    while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
    while(c>='0'&&c<='9'){x=x*10+c-'0';c=getchar();}
    return x*f;
}
struct edge{int to,next;}e[N<<1];
void ins(int u,int v){e[++cnt]=(edge){v,first[u]};first[u]=cnt;}
struct SGT
{
    int l[N*4],r[N*4];
    LL sum[N*4],tag[N*4];
    void build(int x,int L,int R)
    {
        l[x]=L;r[x]=R;if(L==R)return;
        int mid=(L+R)>>1;
        build(lc(x),L,mid);build(rc(x),mid+1,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]+1);}
    void down(int x)
    {
        if(!tag[x])return;
        qadd(lc(x),tag[x]);qadd(rc(x),tag[x]);
        tag[x]=0;
    }
    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])>>1;
        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=0;
        int mid=(l[x]+r[x])>>1;
        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]-1;
    for(int i=16;i>=0;i--)
        if(d&(1<<i))y=fa[y][i];
    return y;
}
void addson(int x,LL w)
{
    if(x==rt)sgt.add(1,1,n,w);
    else if(in[rt]>=in[x]&&out[rt]<=out[x])
    {
        int t=find(x,rt);
        if(in[t]>1)sgt.add(1,1,in[t]-1,w);
        if(out[t]<n)sgt.add(1,out[t]+1,n,w);
    }
    else sgt.add(1,in[x],out[x],w);
}
struct LCT
{
    int c[N][2],fa[N],in[N],out[N];
    bool rev[N];
    bool isroot(int x){return c[fa[x]][0]!=x&&c[fa[x]][1]!=x;}
    void flip(int x){swap(c[x][0],c[x][1]);rev[x]^=1;}
    void down(int x){if(rev[x])flip(c[x][0]),flip(c[x][1]),rev[x]=0;}
    void rotate(int x)
    {
        int y=fa[x],z=fa[y],l,r;
        if(c[y][0]==x)l=0;else l=1;r=l^1;
        if(!isroot(y)){if(c[z][0]==y)c[z][0]=x;else c[z][1]=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][0]==x)^(c[z][0]==y))rotate(x);
                else rotate(y);
            }
            rotate(x);
        }
    }
    int top(int x){down(x);while(c[x][0])x=c[x][0],down(x);return x;}
    void access(int x)
    {
        int t=0;
        while(x)
        {
            splay(x);
            if(c[x][1])addson(top(c[x][1]),1);
            if(t)addson(top(t),-1);
            c[x][1]=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(1,in[x],in[x],deep[x]);
    for(int i=1;(1<<i)<=deep[x];i++)
        fa[x][i]=fa[fa[x][i-1]][i-1];
    for(int i=first[x];i;i=e[i].next)
    {
        int to=e[i].to;
        if(to==fa[x][0])continue;
        fa[to][0]=lct.fa[to]=x;
        deep[to]=deep[x]+1;dfs(to);
    }
    out[x]=dfn;
}
double request(int x)
{
    if(x==rt)return 1.0*sgt.query(1,1,n)/n;
    if(in[rt]>=in[x]&&out[rt]<=out[x])
    {
        int t=find(x,rt);LL sum=0;
        if(in[t]>1)sum+=sgt.query(1,1,in[t]-1);
        if(out[t]<n)sum+=sgt.query(1,out[t]+1,n);
        return 1.0*sum/(n-(out[t]-in[t]+1));
    }
    return 1.0*sgt.query(1,in[x],out[x])/(out[x]-in[x]+1);
}
int main()
{
    n=read();m=read();
    for(int i=1;i<n;i++)x=read(),y=read(),ins(x,y),ins(y,x);
    sgt.build(1,1,n);deep[1]=1;dfs(1);
    while(m--)
    {
        scanf("%s",op);x=read();
        if(op[2]=='Q')printf("%.10lf\n",request(x));
        else
        {
            lct.access(x);
            if(op[2]=='C')lct.makeroot(x);
        }
    }
    return 0;
}