[bzoj1095][ZJOI2007]Hide 捉迷藏 点分树，动态点分治

【bzoj1095】[ZJOI2007]Hide 捉迷藏

2015年4月20日7,8876

Description

捉迷藏 Jiajia和Wind是一对恩爱的夫妻，并且他们有很多孩子。某天，Jiajia、Wind和孩子们决定在家里玩捉迷藏游戏。他们的家很大且构造很奇特，由N个屋子和N-1条双向走廊组成，这N-1条走廊的分布使得任意两个屋子都互相可达。游戏是这样进行的，孩子们负责躲藏，Jiajia负责找，而Wind负责操纵这N个屋子的灯。在起初的时候，所有的灯都没有被打开。每一次，孩子们只会躲藏在没有开灯的房间中，但是为了增加刺激性，孩子们会要求打开某个房间的电灯或者关闭某个房间的电灯。为了评估某一次游戏的复杂性，Jiajia希望知道可能的最远的两个孩子的距离（即最远的两个关灯房间的距离）。 我们将以如下形式定义每一种操作： C(hange) i 改变第i个房间的照明状态，若原来打开，则关闭；若原来关闭，则打开。 G(ame) 开始一次游戏，查询最远的两个关灯房间的距离。

Input

第一行包含一个整数N，表示房间的个数，房间将被编号为1,2,3…N的整数。接下来N-1行每行两个整数a, b，表示房间a与房间b之间有一条走廊相连。接下来一行包含一个整数Q，表示操作次数。接着Q行，每行一个操作，如上文所示。

Output

对于每一个操作Game，输出一个非负整数到hide.out，表示最远的两个关灯房间的距离。若只有一个房间是关着灯的，输出0；若所有房间的灯都开着，输出-1。

Sample Input

8
1 2
2 3
3 4
3 5
3 6
6 7
6 8
7
G
C 1
G
C 2
G
C 1
G

Sample Output

4
3
3
4

HINT

对于100%的数据， N ≤100000, M ≤500000。

C.每个重心存所有子树到其距离

B.每个重心存各个子树最大值，即子结点堆C的最大值

A.全局一个堆，维护答案最大值，存每个堆B的最大值和次大值之和

 

 

 

C的意思是u这个节点，经过u，到达其父亲f的路径的所有距离，

B是维护所有的子节点的C的最大值，

A是维护各个B中的最大值。

 

动态点分治是树上动态添加节点，在这种情况下动态维护点分树的结构

 

这道题目的树的结构是不变的，所以建出点分树即可，

然后维护各个堆的值即可。

 

因为点分树上是log层的，堆维护也是log的，所有每次询问logn

修改logn logn，所有总复杂度是n log^2n

 

计算深度那里十分巧妙，用一个rmq记录，就是通过dfs访问顺序，然后进入一个点记录一次，

这样总共均摊是2*n，和边有关系，

然后rmq记录最小值，发现这个就是lca的深度

然后距离就比较好算了，O(1)算出，

 

 #include<cstring>
 #include<cmath>
 #include<iostream>
 #include<cstdio>
 #include<algorithm>
 #include<queue>

 #define inf 1000000007
 #define N 200007
 #define ll long long
 using namespace std;
 inline int read()
 {
     int x=,f=;char ch=getchar();
     while(ch<''||ch>''){if (ch=='-')f=-;ch=getchar();}
     while(ch>=''&&ch<=''){x=(x<<)+(x<<)+ch-'';ch=getchar();}
     return x*f;
 }

 int n,m,rt,dfn,sum,tot;
 int bin[],Log[N];
 int siz[N],f[N],dep[N];
 int cnt,hed[N],rea[N],nxt[N];
 int mn[][N],pos[N],fa[N];
 bool vis[N],clo[N];
 struct heap
 {
     priority_queue<int> A,B;
     void push(int x){A.push(x);}
     void erase(int x){B.push(x);}
     void pop()
     {
         while(B.size()&&A.top()==B.top())
             A.pop(),B.pop();
         A.pop();
     }
     int top()
     {
         while(B.size()&&A.top()==B.top())
             A.pop(),B.pop();
         if(!A.size())return ;
         return A.top();
     }
     int size(){return A.size()-B.size();}
     int stop()
     {
         if(size()<)return ;
         int x=top();pop();
         int y=top();push(x);
         return y;
     }
 }A,B[],C[];

 void add(int u,int v)
 {
     nxt[++cnt]=hed[u];
     hed[u]=cnt;
     rea[cnt]=v;
 }
 void dfs(int u,int fa)
 {
     mn[][++dfn]=dep[u],pos[u]=dfn;
     for (int i=hed[u];i!=-;i=nxt[i])
     {
         int v=rea[i];
         if (v==fa)continue;
         dep[v]=dep[u]+;
         dfs(v,u);
         mn[][++dfn]=dep[u];
     }
 }
 void get_root(int u,int fa)
 {
     siz[u]=,f[u]=;
     for (int i=hed[u];i!=-;i=nxt[i])
     {
         int v=rea[i];
         if (v==fa||vis[v])continue;
         get_root(v,u);
         siz[u]+=siz[v];
         f[u]=max(f[u],siz[v]);
     }
     f[u]=max(f[u],sum-siz[u]);
     if (f[u]<f[rt])rt=u;
 }
 void divide(int u,int par)
 {
     fa[u]=par,vis[u]=;int sums=sum;
     for (int i=hed[u];i!=-;i=nxt[i])
     {
         int v=rea[i];
         if (vis[v])continue;
         if (siz[v]>siz[u]) sum=sums-siz[u];
         else sum=siz[v];
         rt=;
         get_root(v,u);
         divide(rt,u);
     }
 }
 int rmq(int x,int y)
 {
     x=pos[x],y=pos[y];
     if (y<x)swap(x,y);
     int t=Log[y-x+];
     return min(mn[t][x],mn[t][y-bin[t]+]);
 }
 int dis(int x,int y)
 {
     return dep[x]+dep[y]-*rmq(x,y);
 }
 void turn_off(int u,int v)
 {
     if (u==v)
     {
         B[u].push();
         if (B[u].size()==)A.push(B[u].top());
     }
     if(!fa[u])return;
     int f=fa[u],D=dis(f,v),tmp=C[u].top();
     C[u].push(D);
     if (D>tmp)
     {
         int mx=B[f].top()+B[f].stop(),size=B[f].size();
         if (tmp)B[f].erase(tmp);
         B[f].push(D);
         int now=B[f].top()+B[f].stop();
         if(now>mx)
         {
             if (size>=)A.erase(mx);
             if (B[f].size()>=)A.push(now);
         }
     }
     turn_off(f,v);
 }
 void turn_on(int u,int v)
 {
     if(u==v)
     {
         if(B[u].size()==)A.erase(B[u].top());
         B[u].erase();
     }
     if(!fa[u])return;
     int f=fa[u],D=dis(f,v),tmp=C[u].top();
     C[u].erase(D);
     if(D==tmp)
     {
         int mx=B[f].top()+B[f].stop(),size=B[f].size();
         B[f].erase(D);
         if(C[u].top())B[f].push(C[u].top());
         int now=B[f].top()+B[f].stop();
         if(now<mx)
         {
             if(size>=)A.erase(mx);
             if(B[f].size()>=)A.push(now);
         }
     }
     turn_on(f,v);
 }
 int main()
 {
     bin[]=;for (int i=;i<;i++)bin[i]=bin[i-]<<;//2的幂次
     Log[]=-;for (int i=;i<=;i++)Log[i]=Log[i>>]+;
     n=read();memset(hed,-,sizeof(hed));
     for(int i=;i<n;i++)
     {
         int u=read(),v=read();
         add(u,v),add(v,u);
     }

     dfs(,);//预处理出深度

     for (int i=;i<=Log[dfn];i++)
         for (int j=;j<=dfn;j++)
             if (j+bin[i]-<=dfn) mn[i][j]=min(mn[i-][j],mn[i-][j+bin[i-]]);
     //预处理,处理出向下走2^x步的到达最浅的点，就是起lca的深度。

     rt=,f[]=inf,sum=n;
     get_root(,),divide(rt,);
     for (int i=;i<=n;i++)
         clo[i]=true;
     for (int i=;i<=n;i++)turn_off(i,i);
     tot=n;//tot记录当前多少灯是灭的。
 //    printf("%d\n",A.top());

     char ch[];m=read();
     while(m--)
     {
         scanf("%s",ch+);
         if (ch[]=='G')
         {
             if (tot<=) printf("%d\n",tot-);
             else printf("%d\n",A.top());
         }
         else
         {
             int x=read();
             if (clo[x])turn_on(x,x),tot--;
             else turn_off(x,x),tot++;
             clo[x]^=;
         }
     }
 }