【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
;
int deep
,in
,out
,fa
[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
[2],fa
,in
,out
;
bool rev
;
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;
}

View Code