Bzoj3779 重组病毒

Time Limit: 20 Sec  Memory Limit: 512 MB
Submit: 408  Solved: 163
[Submit][Status][Discuss]

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 < = 1 00 000 M < = 1 00 000

 

 

树 LCT+LCA+线段树 脑洞题

初始的时候，每个结点的权值就是它的深度。

观察发现每个结点的权值实际上就是它access的时候向上经过的虚边数量。

于是1操作就是access，路上把LCT结点的原右儿子所在子树权值全部+1，把新右儿子所在子树权值全部-1，这一过程可以用DFS序+线段树维护

2操作就是makeroot，自带一个access操作

3操作换根比较麻烦，实际上只需要记录当前根，每次仍在最初的树上操作，根据原根与现根的位置关系讨论即可。

↑比如说这种情况，要修改的就是除了nowroot所在子树区间以外的左右两段（图中没有左段）区间

  

/*by SilverN*/
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<vector>
#define LL long long
using namespace std;
const int mxn=100010;
int read(){
    int x=0,f=1;char ch=getchar();
    while(ch<'0' || ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0' && ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
struct edge{
    int v,nxt;
}e[mxn<<1];
int hd[mxn],mct=0;
void add_edge(int u,int v){
    e[++mct].v=v;e[mct].nxt=hd[u];hd[u]=mct;return;
}
namespace TC{
    struct node{
        int fa,top,son;
        int sz;
    }t[mxn];
    int dep[mxn],ind[mxn],out[mxn],dtime;
    int mp[mxn];
    void DFS(int u,int ff){
        dep[u]=dep[ff]+1;
        t[u].sz++;
        for(int i=hd[u],v;i;i=e[i].nxt){
            if(e[i].v==ff)continue;
            v=e[i].v;
            t[v].fa=u;
            DFS(v,u);
            t[u].sz+=t[v].sz;
            if(t[v].sz>t[t[u].son].sz)t[u].son=v;
        }
        return;
    }
    void DFS2(int u,int top){
        ind[u]=++dtime;
        mp[dtime]=u;
        t[u].top=top;
        if(t[u].son){
            DFS2(t[u].son,top);
            for(int i=hd[u];i;i=e[i].nxt){
                if(e[i].v==t[u].son || e[i].v==t[u].fa)continue;
                DFS2(e[i].v,e[i].v);
            }
        }
        out[u]=dtime;
        return;
    }
    int LCA(int x,int y){
        int last=0;
        while(t[x].top!=t[y].top){
            if(dep[t[x].top]<dep[t[y].top])swap(x,y);
            last=t[x].top;
            x=t[t[x].top].fa;
        }
        if(x==y)return last;
            else return t[y].son;
    }
}
int n,m,nowroot;
struct SGT{
    #define lc rt<<1
    #define rc rt<<1|1
    struct node{
        LL smm,mk,mx;
    }t[mxn<<2];
    void pushup(int rt){
        t[rt].smm=t[lc].smm+t[rc].smm;
        return;
    }
    inline void PD(int l,int r,int rt){
        if(t[rt].mk){
            t[lc].mk+=t[rt].mk;
            t[rc].mk+=t[rt].mk;
            int mid=(l+r)>>1;
            t[lc].smm+=t[rt].mk*(LL)(mid-l+1);
            t[rc].smm+=t[rt].mk*(LL)(r-mid);
            t[lc].mx+=t[rt].mk;t[rc].mx+=t[rt].mk;
            t[rt].mk=0;
        }
        return;
    }
    void Build(int l,int r,int rt){
        if(l==r){
            t[rt].smm=t[rt].mx=TC::dep[TC::mp[l]];    return;
        }
        int mid=(l+r)>>1;
        Build(l,mid,lc);Build(mid+1,r,rc);
        pushup(rt);
        return;
    }
    void update(int L,int R,int v,int l,int r,int rt){
        if(L>R)return;
        if(L<=l && r<=R){
            t[rt].mk+=v;
            t[rt].smm+=(LL)v*(LL)(r-l+1);
            return;
        }
        PD(l,r,rt);
        int mid=(l+r)>>1;
        if(L<=mid)update(L,R,v,l,mid,lc);
        if(R>mid)update(L,R,v,mid+1,r,rc);
        pushup(rt);
        return;
    }
    LL qsum(int L,int R,int l,int r,int rt){
        if(L>R)return 0;
        if(L<=l && r<=R){return t[rt].smm;}
        PD(l,r,rt);
        LL res=0;
        int mid=(l+r)>>1;
        if(L<=mid)res+=qsum(L,R,l,mid,lc);
        if(R>mid)res+=qsum(L,R,mid+1,r,rc);
        pushup(rt);
        return res;
    }
    void Q_UPD(int x,int v){
        using namespace TC;
        int rt=nowroot;
        if(rt==x)update(1,n,v,1,n,1);
        else 
            if(ind[x]<ind[rt] && out[rt]<=out[x]){//两段区间 
                rt=LCA(rt,x);
                update(1,ind[rt]-1,v,1,n,1);
                update(out[rt]+1,n,v,1,n,1);
            }
            else update(ind[x],out[x],v,1,n,1);
    }
    double Query(int x){
        using namespace TC;
        LL ans=0,sz=0;
        int rt=nowroot;
        if(rt==x)ans=qsum(1,n,1,n,1),sz=n;
        else if(ind[x]<ind[rt] && out[rt]<=out[x]){
                rt=LCA(rt,x);
                ans+=qsum(1,ind[rt]-1,1,n,1);
                ans+=qsum(out[rt]+1,n,1,n,1);
                sz=n-(out[rt]-ind[rt]+1);
            }
            else{
                ans=qsum(ind[x],out[x],1,n,1),sz=out[x]-ind[x]+1;
            }
        double res=(double)ans/(double)sz;
        printf("%.10f\n",res);
        return res;
    }
    #undef lc
    #undef rc
}sgt;
struct LCT{
    int ch[mxn][2],fa[mxn];
    bool rev[mxn];
    int st[mxn],top;
    inline bool isroot(int x){return (ch[fa[x]][0]!=x && ch[fa[x]][1]!=x);}
    void PD(int rt){
        if(rev[rt]){
            rev[ch[rt][0]]^=1;    rev[ch[rt][1]]^=1;
            swap(ch[rt][0],ch[rt][1]);
            rev[rt]^=1;
        }
        return;
    }
    void rotate(int x){
        int y=fa[x],z=fa[y],lc,rc;
        if(ch[y][0]==x)lc=0;else lc=1; rc=lc^1;
        if(!isroot(y)) ch[z][ch[z][1]==y]=x;
        fa[x]=z;fa[y]=x;
        fa[ch[x][rc]]=y;
        ch[y][lc]=ch[x][rc]; ch[x][rc]=y;
        return;
    }
    void Splay(int x){
        st[top=1]=x;
        for(int i=x;!isroot(i);i=fa[i])    st[++top]=fa[i];
        while(top)PD(st[top--]);
        while(!isroot(x)){
            int y=fa[x],z=fa[y];
            if(!isroot(y)){
                if((ch[z][0]==y)^(ch[y][0]==x))rotate(x);
                else rotate(y);
            }
            rotate(x);
        }
    }
    void access(int x){
        for(int y=0;x;x=fa[x]){
            Splay(x);
            if(ch[x][1]){
                int now=ch[x][1];    PD(now);
                while(ch[now][0]){now=ch[now][0];PD(now);}
                sgt.Q_UPD(now,1);
            }
            if(y){
                int now=y;    PD(now);
                while(ch[now][0]){now=ch[now][0];PD(now);}
                sgt.Q_UPD(now,-1);
            }
            ch[x][1]=y;
            y=x;
        }
        return;
    }
    void mkroot(int x){
        access(x);Splay(x);
        rev[x]^=1;
        nowroot=x;
        return;
    }
}LT;
void solve(){
    char opt[10];int x;
    while(m--){
        scanf("%s%d",opt,&x);
        if(opt[2]=='Q'){sgt.Query(x);continue;}//REQUEST
        else if(opt[2]=='C'){LT.mkroot(x);continue;}//RECENTER
        else if(opt[2]=='L'){LT.access(x);continue;}//RELEASE
//        else Debug();
    }
    return;
}
int main(){
    int i,j;
    n=read();m=read();
    int u,v;
    for(i=1;i<n;i++){
        u=read();v=read();
        add_edge(u,v);add_edge(v,u);
    }
    TC::DFS(1,0);
    TC::DFS2(1,1);
    for(i=1;i<=n;i++) LT.fa[i]=TC::t[i].fa;    
    sgt.Build(1,n,1);
    nowroot=1;
    solve();
    return 0;
}

 

Time Limit: 20 Sec  Memory Limit: 512 MB
Submit: 408  Solved: 163
[Submit][Status][Discuss]

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 < = 1 00 000 M < = 1 00 000