[BZOJ1095][ZJOI2007]Hide 捉迷藏（动态点分治）

题目：

我是超链接

题意：

给出一棵树，树上的每个点有黑白两种状态，求树上最远两个黑点的距离。
会改变点的状态。

题解：

首先如果不是有修改的话直接就是裸的点分治了吧
首先回顾一下点分治，其实就是每次找重心，然后处理与重心相关的路径，时间复杂度的保证在于树高不会超过logn，那么对于一个点来说，最多被统计log次，如果统计是O(1)，那么均摊时间复杂度是O(nlogn)
动态点分治相当于用线段树处理序列问题一样，在点分治的基础上加上对于每个点关键信息的维护，一般是加入一个数据结构，实现快速的查询和修改

动态点分治的实现过程

以这道题目为例
1、建立重心树
在点分治中真正用了更新答案的实际上是重心上的路径信息，所以对于每个点我们只需要维护其作为重心时的有关信息即可。我们先根据找到的重心建立一棵重心树，一个点作为重心时隔开后得到的若干棵子树，其每个重心的父重心就是这个点。根据点分治的性质，一个点的改变只会影响这个点作为重心时重心树上的所有祖先节点

因为重心树的高是logn的，所以每次修改一个点，最多只需要修改logn个节点维护的信息
重心树可以不实际建出来，只需要记录一下每个点的父重心就好，然后找pre就行

2、构造可删堆（或者其他数据结构）
如果是静态的，对于每个点，我们只需要知道他作为重心的时候经过他的两个黑点形成的最长链，如果是动态的话，点状态的改变会影响最长链的选取，所以我们需要将这些黑点到重心的信息记录下来，并维护最大值。对于这道题目来说，堆是个不错的选择

堆的话，一般可以用STL的优先队列来代替（空间用多少算多少），但是有一个弊端就是不支持删除任意点，那么我们考虑怎么利用两个堆实现动态删除的效果

对于每个维护最大值的堆，再开一个删除堆，删除一个节点的时候，我们将要删除的值放到删除堆中，每次取top的时候，如果两个堆的堆顶元素是一样的就同时pop，直到两个堆的top不同或者删除堆为空，此时的堆顶就是真正的堆顶

3、维护信息
对于每个点维护两个堆，第一个堆C维护这个重心的子树中的点到父重心的距离（是这个重心的父重心）。第二个堆B维护这个重心的所有子重心中黑点的最大深度（也就是所有子重心的C堆堆顶）。最后用一个堆A维护所有重心B堆的最大值和次大值的和，A的堆顶就是答案。注意如果某个点是黑点，这个点的B堆中还要加一个距离0，确保这个点和子树中的黑点可以组成路径

4、修改操作
把白点变黑点和黑点变白点分开考虑。先从C堆修改，如果C影响B，那么修改B，B的变化影响A就改A，反正按照优先级修改就行。

代码：

#include <cstdio>
#include <iostream>
#include <queue>
using namespace std;
const int N=100005;
const int INF=1e9;
const int sz=18;
int tot,nxt[N*2],point[N],v[N*2],z[N],f[N][sz+5],mi[sz+5],size[N],h[N],sum,root,pre[N];
bool vis[N],ad[N];
struct heap
{
    priority_queue<int> h,d;
    void push(int x){h.push(x);}
    void del(int x){d.push(x);}
    void pop()
    {
        while (!d.empty() && h.top()==d.top()) h.pop(),d.pop();
        h.pop();
    }
    int top()
    {
        while (!d.empty() && h.top()==d.top()) h.pop(),d.pop();
        if (!h.size()) return 0;
        return h.top();
    }
    int sectop()
    {
        if (size()<2) return 0;
        int t=top(); pop();
        int t1=top(); push(t);
        return t1;
    }
    int size(){return h.size()-d.size();}
}a,b[N],c[N];
void addline(int x,int y)
{
    ++tot; nxt[tot]=point[x]; point[x]=tot; v[tot]=y;
    ++tot; nxt[tot]=point[y]; point[y]=tot; v[tot]=x;
}
void dfs(int x,int fa)
{
    h[x]=h[fa]+1; 
    for (int i=1;i<sz;i++)
      if (h[x]<mi[i]) break;
      else f[x][i]=f[f[x][i-1]][i-1];
    for (int i=point[x];i;i=nxt[i])
      if (v[i]!=fa) f[v[i]][0]=x,dfs(v[i],x);
}
int lca(int x,int y)
{
    if (h[x]<h[y]) swap(x,y);
    int k=h[x]-h[y];
    for (int i=0;i<sz;i++)
      if (k>>i&1) x=f[x][i];
    if (x==y) return x;
    for (int i=sz-1;i>=0;i--)
      if (f[x][i]!=f[y][i]) x=f[x][i],y=f[y][i];
    return f[x][0];
}
int Dis(int x,int y){return h[x]+h[y]-2*h[lca(x,y)];}
void getroot(int x,int fa)
{
    size[x]=1; z[x]=0;
    for (int i=point[x];i;i=nxt[i])
      if (v[i]!=fa && !vis[v[i]])
      {
        getroot(v[i],x);
        size[x]+=size[v[i]];
        z[x]=max(z[x],size[v[i]]);
      }
    z[x]=max(z[x],sum-size[x]);
    if (z[x]<z[root]) root=x;
}
void work(int x,int fa)
{
    pre[x]=fa; vis[x]=1;
    for (int i=point[x];i;i=nxt[i])
      if (!vis[v[i]])
      {
        sum=size[v[i]]; root=0; z[0]=INF; 
        getroot(v[i],x); work(root,x); 
      }
}
void turnoff(int go,int x)
{
    if (go==x)
    {
        b[x].push(0);
        if (b[x].size()==2) a.push(b[x].top());
    }
    if (!pre[go]) return;
    int fa=pre[go],dis=Dis(fa,x),tmp=c[go].top();
    c[go].push(dis);
    if (dis>tmp)
    {
        int maxx=b[fa].top()+b[fa].sectop(),siz=b[fa].size();
        if (tmp) b[fa].del(tmp);
        //因为子树里有另一个更好的值，而b数组对于一个子树里只能存一个 
        b[fa].push(dis);
        int now=b[fa].top()+b[fa].sectop();
        if (now>maxx)
        {
            if (siz>=2) a.del(maxx);
            if (b[fa].size()>=2) a.push(now);
        }
    }
    turnoff(fa,x);
}
void turnon(int go,int x)
{
    if (go==x)
    {
        if (b[x].size()==2) a.del(b[x].top());
        b[x].del(0);
    }
    if (!pre[go]) return;
    int fa=pre[go],dis=Dis(fa,x),tmp=c[go].top();
    c[go].del(dis);
    if (dis==tmp)
    {
        int maxx=b[fa].top()+b[fa].sectop(),siz=b[fa].size();
        b[fa].del(dis);
        if (c[go].top()) b[fa].push(c[go].top()); 
        int now=b[fa].top()+b[fa].sectop();
        if (now<maxx)
        {
            if (siz>=2) a.del(maxx);
            if (b[fa].size()>=2) a.push(now);
        }
    }
    turnon(fa,x);
}
int main()
{
    int n,light,q;scanf("%d",&n);light=n;
    for (int i=1;i<n;i++)
    {
        int x,y;scanf("%d%d",&x,&y);
        addline(x,y);
    }
    mi[0]=1;for (int i=1;i<sz;i++) mi[i]=mi[i-1]*2; 
    dfs(1,0);sum=n; root=0; z[0]=INF; 
    getroot(1,0); work(root,0);
    for (int i=1;i<=n;i++) ad[i]=1,c[i].push(0); 
    for (int i=1;i<=n;i++) turnoff(i,i);
    scanf("%d",&q);
    while (q--)
    {
        char st[5];scanf("%s",st);
        if (st[0]=='G')
        {
            if (light<=1) printf("%d\n",light-1);
            else printf("%d\n",a.top()); 
        }
        else
        {
            int x;scanf("%d",&x);
            if (ad[x]) turnon(x,x),light--;
            else turnoff(x,x),light++;
            ad[x]^=1;
        }
    }
}