[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=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if (ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=(x<<3)+(x<<1)+ch-'0';ch=getchar();}
    return x*f;
}

int n,m,rt,dfn,sum,tot;
int bin[22],Log[N];
int siz[N],f[N],dep[N];
int cnt,hed[N],rea[N],nxt[N];
int mn[19][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 0;
        return A.top();
    }
    int size(){return A.size()-B.size();}
    int stop()
    {
        if(size()<2)return 0;
        int x=top();pop();
        int y=top();push(x);
        return y;
    }
}A,B[100005],C[100005];

void add(int u,int v)
{
    nxt[++cnt]=hed[u];
    hed[u]=cnt;
    rea[cnt]=v;
}
void dfs(int u,int fa)
{
    mn[0][++dfn]=dep[u],pos[u]=dfn;
    for (int i=hed[u];i!=-1;i=nxt[i])
    {
        int v=rea[i];
        if (v==fa)continue;
        dep[v]=dep[u]+1;
        dfs(v,u);
        mn[0][++dfn]=dep[u];
    }
}
void get_root(int u,int fa)
{
    siz[u]=1,f[u]=0;
    for (int i=hed[u];i!=-1;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]=1;int sums=sum;
    for (int i=hed[u];i!=-1;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=0;
        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+1];
    return min(mn[t][x],mn[t][y-bin[t]+1]);
}
int dis(int x,int y)
{
    return dep[x]+dep[y]-2*rmq(x,y);
}
void turn_off(int u,int v)
{
    if (u==v)
    {
        B[u].push(0);
        if (B[u].size()==2)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>=2)A.erase(mx);
            if (B[f].size()>=2)A.push(now);
        }
    }
    turn_off(f,v);
}
void turn_on(int u,int v)
{
    if(u==v)
    {
        if(B[u].size()==2)A.erase(B[u].top());
        B[u].erase(0);
    }
    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>=2)A.erase(mx);
            if(B[f].size()>=2)A.push(now);
        }
    }
    turn_on(f,v);
}
int main()
{
    bin[0]=1;for (int i=1;i<20;i++)bin[i]=bin[i-1]<<1;//2的幂次
    Log[0]=-1;for (int i=1;i<=200000;i++)Log[i]=Log[i>>1]+1;
    n=read();memset(hed,-1,sizeof(hed));
    for(int i=1;i<n;i++)
    {
        int u=read(),v=read();
        add(u,v),add(v,u);
    }
    
    dfs(1,0);//预处理出深度
    
    for (int i=1;i<=Log[dfn];i++)
        for (int j=1;j<=dfn;j++)
            if (j+bin[i]-1<=dfn) mn[i][j]=min(mn[i-1][j],mn[i-1][j+bin[i-1]]);
    //预处理,处理出向下走2^x步的到达最浅的点，就是起lca的深度。

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

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