BZOJ1095:[ZJOI2007]Hide 捉迷藏(动态点分治)

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。

Solution

维护三个堆。

$h1[x]$存当前重心$x$管辖的范围内的点到$x$在点分树上的父亲的所有距离。

$h2[x]$存$x$在点分树上所有儿子的$h1$堆的堆顶。

$h3$存每个点的答案。

关灯的点$h2$自带一个$0$方便处理单链……

反正快退役了也不想写太多了……还有问题看代码吧……

Code

 #include<iostream>
 #include<cstring>
 #include<cstdio>
 #include<queue>
 #define N (100009)
 using namespace std;

 struct Heap
 {
     priority_queue<int>q,del;
     void push(int x) {q.push(x);}
     void erase(int x) {del.push(x);}
     bool empty() {return q.size()-del.size()==;}
     int size() {return q.size()-del.size();}
     int top()
     {
         while (!del.empty() && q.top()==del.top()) q.pop(), del.pop();
         return q.top();
     }
     void pop()
     {
         while (!del.empty() && q.top()==del.top()) q.pop(), del.pop();
         return q.pop();
     }
     int sec()
     {
         if (size()<) return -;
         int tmp1=top(); pop();
         int tmp2=top(); push(tmp1);
         return tmp2;
     }
 }h1[N],h2[N],h3;

 struct Edge{int to,next;}edge[N<<];
 int n,m,root,sum,light_num;
 int s[N],f[N][],fa[N],dep[N],maxsize[N],size[N],vis[N];
 int head[N],num_edge;

 inline int read()
 {
     int x=,w=; char c=getchar();
     while (c<'' || c>'') {if (c=='-') w=-; c=getchar();}
     while (c>='' && c<='') x=x*+c-'', c=getchar();
     return x*w;
 }

 void add(int u,int v)
 {
     edge[++num_edge].to=v;
     edge[num_edge].next=head[u];
     head[u]=num_edge;
 }

 void DFS(int x,int fa)
 {
     dep[x]=dep[fa]+; f[x][]=fa;
     for (int i=; i<=; ++i) f[x][i]=f[f[x][i-]][i-];
     for (int i=head[x]; i; i=edge[i].next)
         if (edge[i].to!=fa) DFS(edge[i].to,x);
 }

 void Get_Root(int x,int fa)
 {
     size[x]=; maxsize[x]=;
     for (int i=head[x]; i; i=edge[i].next)
         if (!vis[edge[i].to] && edge[i].to!=fa)
         {
             Get_Root(edge[i].to,x);
             size[x]+=size[edge[i].to];
             maxsize[x]=max(maxsize[x], size[edge[i].to]);
         }
     maxsize[x]=max(maxsize[x],sum-size[x]);
     if (maxsize[x]<maxsize[root]) root=x;
 }

 void Solve(int x)
 {
     vis[x]=;
     for (int i=head[x]; i; i=edge[i].next)
         if (!vis[edge[i].to])
         {
             sum=size[edge[i].to]; root=;
             Get_Root(edge[i].to,x);
             fa[root]=x; Solve(root);
         }
 }

 int LCA(int x,int y)
 {
     if (dep[x]<dep[y]) swap(x,y);
     for (int i=; i>=; --i)
         if (dep[f[x][i]]>=dep[y]) x=f[x][i];
     if (x==y) return x;
     for (int i=; i>=; --i)
         if (f[x][i]!=f[y][i]) x=f[x][i], y=f[y][i];
     return f[x][];
 }

 void Insert(int x)
 {
     if (h2[x].size()>=)
         h3.push(h2[x].top()+h2[x].sec());
 }

 void Delete(int x)
 {
     if (h2[x].size()>=)
         h3.erase(h2[x].top()+h2[x].sec());
 }

 void Turn_off(int x)
 {
     Delete(x); h2[x].push(); Insert(x);
     light_num--;
     for (int t=x,ft=fa[t]; ft; t=fa[t],ft=fa[t])
     {
         Delete(ft);
         if (!h1[t].empty()) h2[ft].erase(h1[t].top());
         h1[t].push(dep[x]+dep[ft]-*dep[LCA(x,ft)]);
         h2[ft].push(h1[t].top());
         Insert(ft);
     }
 }

 void Turn_on(int x)
 {
     Delete(x); h2[x].erase(); Insert(x);
     light_num++;
     for (int t=x,ft=fa[t]; ft; t=fa[t],ft=fa[t])
     {
         Delete(ft);
         if (!h1[t].empty()) h2[ft].erase(h1[t].top());
         h1[t].erase(dep[x]+dep[ft]-*dep[LCA(x,ft)]);
         if (!h1[t].empty()) h2[ft].push(h1[t].top());
         Insert(ft);
     }
 }

 int main()
 {
     n=read(); sum=maxsize[]=n;
     for (int i=; i<=n-; ++i)
     {
         int u=read(),v=read();
         add(u,v); add(v,u);
     }
     DFS(,);
     Get_Root(,);
     Solve(root);
     for (int i=; i<=n; ++i) Turn_off(i);
     light_num=;
     m=read();
     while (m--)
     {
         char opt=getchar();
         while (opt!='C' && opt!='G') opt=getchar();
         if (opt=='C')
         {
             int x=read();
             if (!s[x]) Turn_on(x);
             else Turn_off(x);
             s[x]^=;
         }
         else
         {
             if (light_num>=n-) puts(light_num==n?"-1":"");
             else printf("%d\n",h3.top());
         }
     }
 }