【Foreign】染色 [LCT][线段树]

染色

Time Limit: 20 Sec  Memory Limit: 256 MB

Description

　　

Input

　　

Output

　　

Sample Input

　　13
　　0 1
　　0 2
　　1 11
　　1 10
　　1 9
　　9 12
　　2 5
　　5 8
　　2 4
　　2 3
　　4 6
　　4 7
　　7
　　q 0
　　O 4
　　q 6
　　q 2
　　O 9
　　q 9
　　q 2

Sample Output

　　2.0000000000
　　1.0000000000
　　0.8571428571
　　0.5000000000
　　1.8571428571

HINT

　　

Main idea

　　询问x到根路径上不同颜色的个数，支持将x到根的路径上的点全部设为新的颜色。

Solution

　　我们将边两端的点颜色相同的边设为实边，不同的设为虚边。那么一次新增颜色的操作显然就是LCT的access操作！access的时候恰是虚边和实边的转换。

　　那么我们只要用线段树维护每个点到根的贡献，结合dfs序来实现子树加，每次在LCT进行access的时候进行+-1修改，然后询问的时候用区间求和求得答案即可。

Code

 #include<iostream>
 #include<string>
 #include<algorithm>
 #include<cstdio>
 #include<cstring>
 #include<cstdlib>
 #include<ctime>
 #include<cmath>
 using namespace std;
 typedef long long s64;
 const int ONE=;

 int n,m,x,y;
 int pos[ONE],size[ONE],Dep[ONE],dfn[ONE],cnt;
 s64 res;
 char ch[];

 int lc[ONE],rc[ONE],fa[ONE];

 int get()
 {
         int res=,Q=;char c;
         while( (c=getchar())< || c> )
         if(c=='-')Q=-;
         res=c-;
         while( (c=getchar())>= && c<= )
         res=res*+c-;
         return res*Q;
 }

 namespace tree
 {
         int next[ONE],first[ONE],go[ONE],tot;

         void Add(int u,int v)
         {
             next[++tot]=first[u];    first[u]=tot;    go[tot]=v;
             next[++tot]=first[v];    first[v]=tot;    go[tot]=u;
         }

         void Dfs(int u,int father)
         {
             pos[u] = ++cnt; dfn[cnt] = u;
             size[u] = ;
             for(int e=first[u];e;e=next[e])
             {
                 int v=go[e];
                 if(v==father) continue;
                 Dep[v] = Dep[u] + ;
                 fa[v] = u;
                 Dfs(v,u);
                 size[u] += size[v];
             }
         }
 }

 namespace Seg
 {
         struct power
         {
             s64 add,value;
         }Node[ONE];

         void pushdown(int i,int Q)
         {
             if(Node[i].add)
             {
                 Node[i<<].add+=Node[i].add;
                 Node[i<<|].add+=Node[i].add;
                 Node[i<<].value+=Node[i].add*(Q-Q/);
                 Node[i<<|].value+=Node[i].add*(Q/);
                 Node[i].add=;
             }
         }

         void Build(int i,int l,int r)
         {
             if(l==r)
             {
                 Node[i].value = Dep[dfn[l]];
                 return;
             }
             int mid=(l+r)>>;
             Build(i<<,l,mid);    Build(i<<|,mid+,r);
             Node[i].value=Node[i<<].value+Node[i<<|].value;
         }

         void Update(int i,int l,int r,int L,int R,int x)
         {
             if(L<=l && r<=R)
             {
                 Node[i].add+=x;
                 Node[i].value+=(s64)(r-l+)*x;
                 return;
             }

             pushdown(i,r-l+);
             int mid=(l+r)>>;
             if(L<=mid) Update(i<<,l,mid,L,R,x);
             if(mid+<=R) Update(i<<|,mid+,r,L,R,x);
             Node[i].value=Node[i<<].value+Node[i<<|].value;
         }

         void Query(int i,int l,int r,int L,int R)
         {
             if(L<=l && r<=R)
             {
                 res+=Node[i].value;
                 return;
             }
             pushdown(i,r-l+);
             int mid=(l+r)>>;
             if(L<=mid) Query(i<<,l,mid,L,R);
             if(mid+<=R) Query(i<<|,mid+,r,L,R);
         }
 }

 namespace LCT
 {
         int is_real(int x)
         {
             return (lc[fa[x]]==x || rc[fa[x]]==x);
         }

         void Turn(int x)
         {
             int y=fa[x],z=fa[y];
             int b= x==lc[y] ? rc[x]:lc[x];

             fa[x]=z;    fa[y]=x;
             if(b) fa[b]=y;

             if(z)
             {
                 if(y==lc[z]) lc[z]=x;
                 else
                 if(y==rc[z]) rc[z]=x;
             }

             if(x==lc[y]) rc[x]=y,lc[y]=b;
             else lc[x]=y,rc[y]=b;
         }

         void Splay(int x)
         {
             while(is_real(x))
             {
                 if(is_real(fa[x]))
                 {
                     if( (lc[fa[x]]==x) == (lc[fa[fa[x]]]==fa[x]) ) Turn(fa[x]);
                     else Turn(x);
                 }
                 Turn(x);
             }
         }

         int find_root(int x)
         {
             while(lc[x]) x=lc[x];
             return x;
         }

         void access(int x)
         {
             for(int p=x,q=; p; q=p,p=fa[p])
             {
                 Splay(p);
                 if(rc[p])
                 {
                     int N=find_root(rc[p]);
                     Seg::Update(,,n,pos[N],pos[N]+size[N]-,+);
                 }
                 rc[p]=q;
                 if(rc[p])
                 {
                     int N=find_root(rc[p]);
                     Seg::Update(,,n,pos[N],pos[N]+size[N]-,-);
                 }
             }
         }
 }

 int main()
 {
         n=get();
         for(int i=;i<n;i++)
         {
             x=get();    y=get();
             x++;    y++;
             tree::Add(x,y);
         }
         tree::Dfs(,);
         Seg::Build(,,n);

         m=get();
         while(m--)
         {
             scanf("%s",ch);    x=get(); x++;
             if(ch[]=='O')
             {
                 LCT::access(x);
             }
             else
             {
                 res=;
                 Seg::Query(,,n,pos[x],pos[x]+size[x]-);
                 printf("%.10lf\n",(double)res/size[x]);
             }
         }

 }