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

解题思路：

可以将开灯的点都压缩一下，那么这道题就变成了动态求一颗树的直径。

静态的直径可以由一个点子树中不重复的最大值和次大值来更新。

那么可以考虑更新一个点后重新实现Dfs回溯过程，这时候，我们就需要用一个堆来记录这个点的最长链。

那样问题就变成了枚举两个儿子更新答案。

实际上这是不需要的，在每个点再开一个堆记录答案就好了。

最后将每个点的答案记录到的答案推入答案堆中。

这个复杂度还是不能承受。

将树重构形成点分树，每次都在树中暴力更新答案（注意距离要重新到原树中计算）。

代码：（不想写带删除优先队列，就写了个Treap好慢啊QAQ）

#include<ctime>
#include<cstdio>
#include<cstring>
#include<algorithm>
typedef long long lnt;
const int N=100010;
struct pnt{
    int f;
    int fa;
    int hd;
    int dp;
    int tp;
    int dis;
    int wgt;
    int val;
    int mxs;
    int dcrt;
    int cnrt;
    bool vis;
}p[N];
struct trnt{
    int ls;
    int rs;
    int val;
    int num;
    int wgt;
    int rnd;
}tr[N*80],strn;
struct ent{
    int twd;
    int lst;
}e[N<<1];
int n,m;
int cnt;
int dfn;
int siz;
int top;
int del;
int bnum;
int root;
int size;
int maxsize;
int ansroot;
int sta[N];
int bin[N*80];
char cmd[1000];
void pushup(int rt)
{
    if(!rt)
        return ;
    tr[rt].wgt=tr[tr[rt].ls].wgt+tr[tr[rt].rs].wgt+tr[rt].num;
    return ;
}
void lturn(int &rt)
{
    int ll=tr[rt].ls;
    tr[rt].ls=tr[ll].rs;
    tr[ll].rs=rt;
    pushup(rt);
    rt=ll;
    pushup(rt);
    return ;
}
void rturn(int &rt)
{
    int rr=tr[rt].rs;
    tr[rt].rs=tr[rr].ls;
    tr[rr].ls=rt;
    pushup(rt);
    rt=rr;
    pushup(rt);
    return ;
}
int newp(void)
{
    if(bnum)
        return bin[bnum--];
    return ++siz;
}
void apply(int &rt)
{
    rt=newp();
    tr[rt]=strn;
    tr[rt].num=1;
    tr[rt].rnd=rand();
    return ;
}
void Del(int rt)
{
    bin[++bnum]=rt;
    return ;
}
void Insert(int &rt,int v)
{
    if(!rt)
    {
        apply(rt);
        tr[rt].val=v;
        pushup(rt);
        return ;
    }
    if(tr[rt].val==v)
        tr[rt].num++;
    else if(tr[rt].val>v)
    {
        Insert(tr[rt].ls,v);
        if(tr[rt].rnd>tr[tr[rt].ls].rnd)
            lturn(rt);
    }else{
        Insert(tr[rt].rs,v);
        if(tr[rt].rnd>tr[tr[rt].rs].rnd)
            rturn(rt);
    }
    pushup(rt);
    return ;
}
void Delete(int &rt,int v)
{
    if(!rt)
        return ;
    if(tr[rt].val==v)
    {
        if(tr[rt].num<=1)
        {
            if(!tr[rt].ls||!tr[rt].rs)
            {
                Del(rt);
                rt=tr[rt].ls+tr[rt].rs;
                return ;
            }else{
                if(tr[tr[rt].ls].rnd<tr[tr[rt].rs].rnd)
                {
                    lturn(rt);
                    Delete(tr[rt].rs,v);
                }else{
                    rturn(rt);
                    Delete(tr[rt].ls,v);
                }
            }
        }else
            tr[rt].num--;
    }else if(tr[rt].val>v)
        Delete(tr[rt].ls,v);
    else
        Delete(tr[rt].rs,v);
    pushup(rt);
    return ;
}
int kth(int rt,int k)
{
    if(tr[tr[rt].ls].wgt>=k)
        return kth(tr[rt].ls,k);
    if(tr[tr[rt].ls].wgt+tr[rt].num>=k)
        return tr[rt].val;
    return kth(tr[rt].rs,k-tr[tr[rt].ls].wgt-tr[rt].num);
}
int Maxval(int rt)
{
    if(tr[rt].wgt==0)
        return -0x3f3f3f3f;
    return kth(rt,tr[rt].wgt);
}
int Secval(int rt)
{
    if(tr[rt].wgt<=1)
        return -0x3f3f3f3f;
    return kth(rt,tr[rt].wgt-1);
}
int Chain(int rt)
{
    if(tr[rt].wgt<2)
        return 0;
    return std::max(0,Maxval(rt)+Secval(rt));
}
void ade(int f,int t)
{
    cnt++;
    e[cnt].twd=t;
    e[cnt].lst=p[f].hd;
    p[f].hd=cnt;
    return ;
}
void Basic_dfs(int x,int f)
{
    p[x].wgt=1;
    p[x].f=f;
    p[x].dp=p[f].dp+1;
    int maxs=-1;
    for(int i=p[x].hd;i;i=e[i].lst)
    {
        int to=e[i].twd;
        if(to==f)
            continue;
        p[to].dis=p[x].dis+1;
        Basic_dfs(to,x);
        p[x].wgt+=p[to].wgt;
        if(maxs<p[to].wgt)
        {
            maxs=p[to].wgt;
            p[x].mxs=to;
        }
    }
    return ;
}
void Build_dfs(int x,int top)
{
    if(!x)
        return ;
    p[x].tp=top;
    Build_dfs(p[x].mxs,top);
    for(int i=p[x].hd;i;i=e[i].lst)
    {
        int to=e[i].twd;
        if(to==p[x].f||to==p[x].mxs)
            continue;
        Build_dfs(to,to);
    }
    return ;
}
int Lca(int x,int y)
{
    while(p[x].tp!=p[y].tp)
    {
        if(p[p[x].tp].dp<p[p[y].tp].dp)
            std::swap(x,y);
        x=p[p[x].tp].f;
    }
    if(p[x].dp>p[y].dp)
        std::swap(x,y);
    return x;
}
int Dis(int x,int y)
{
    int z=Lca(x,y);
    return p[x].dis+p[y].dis-2*p[z].dis;
}
void grc_dfs(int x,int f)
{
    sta[++top]=x;
    p[x].wgt=1;
    int maxs=-1;
    for(int i=p[x].hd;i;i=e[i].lst)
    {
        int to=e[i].twd;
        if(to==f||p[to].vis)
            continue;
        grc_dfs(to,x);
        p[x].wgt+=p[to].wgt;
        if(maxs<p[to].wgt)
            maxs=p[to].wgt;
    }
    maxs=std::max(maxs,size-p[x].wgt);
    if(maxs<maxsize)
    {
        root=x;
        maxsize=maxs;
    }
    return ;
}
void bin_dfs(int x,int f)
{
    p[x].fa=f;
    p[x].vis=true;
    int tmp=size;
    if(f)
        for(int i=1;i<=top;i++)
            Insert(p[x].cnrt,Dis(f,sta[i]));
    Insert(p[x].dcrt,0);
    for(int i=p[x].hd;i;i=e[i].lst)
    {
        int to=e[i].twd;
        if(p[to].vis)
            continue;
        root=0;
        top=0;
        if(p[to].wgt<p[x].wgt)
            size=p[to].wgt;
        else
            size=tmp-p[x].wgt;
        maxsize=0x3f3f3f3f;
        grc_dfs(to,to);
        int rt=root;
        bin_dfs(root,x);
        Insert(p[x].dcrt,Maxval(p[rt].cnrt));
    }
    Insert(ansroot,Chain(p[x].dcrt));
    return ;
}
void Update(int oldans,int newans)
{
    if(oldans==newans)
        return ;
    Delete(ansroot,oldans);
    Insert(ansroot,newans);
    return ;
}
void Insert(int x)
{
    int la,na,lc,nc;
    la=Chain(p[x].dcrt);
    Insert(p[x].dcrt,0);
    na=Chain(p[x].dcrt);
    Update(la,na);
    for(int i=x;p[i].fa;i=p[i].fa)
    {
        lc=Maxval(p[i].cnrt);
        Insert(p[i].cnrt,Dis(x,p[i].fa));
        nc=Maxval(p[i].cnrt);
        if(lc==nc)
            continue;
        la=Chain(p[p[i].fa].dcrt);
        if(lc!=-0x3f3f3f3f)
            Delete(p[p[i].fa].dcrt,lc);
        Insert(p[p[i].fa].dcrt,nc);
        na=Chain(p[p[i].fa].dcrt);
        Update(la,na);
    }
    return ;
}
void Delete(int x)
{
    int la,na,lc,nc;
    la=Chain(p[x].dcrt);
    Delete(p[x].dcrt,0);
    na=Chain(p[x].dcrt);
    Update(la,na);
    for(int i=x;p[i].fa;i=p[i].fa)
    {
        lc=Maxval(p[i].cnrt);
        Delete(p[i].cnrt,Dis(x,p[i].fa));
        nc=Maxval(p[i].cnrt);
        if(lc==nc)
            continue;
        la=Chain(p[p[i].fa].dcrt);
        Delete(p[p[i].fa].dcrt,lc);
        if(nc!=-0x3f3f3f3f)
            Insert(p[p[i].fa].dcrt,nc);
        na=Chain(p[p[i].fa].dcrt);
        Update(la,na);
    }
    return ;
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<n;i++)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        ade(a,b);
        ade(b,a);
    }
    Basic_dfs(1,1);
    Build_dfs(1,1);
    root=0;
    size=n;
    maxsize=0x3f3f3f3f;
    grc_dfs(1,1);
    bin_dfs(root,0);
    scanf("%d",&m);
    while(m--)
    {
        scanf("%s",cmd+1);
        if(cmd[1]=='G')
        {
            if(del==n)
                puts("-1");
            else if(del==n-1)
                puts("0");
            else
                printf("%d
",Maxval(ansroot));
        }else{
            int x;
            scanf("%d",&x);
            p[x].val^=1;
            if(p[x].val)
            {
                Delete(x);
                del++;
            }else{
                Insert(x);
                del--;
            }
        }
    }
    return 0;
}