[SPOJ2666][ZJOI2007]捉迷藏Query on a tree IV(树链剖分)(论文做法)

Posted 2021-03-05 birchtree

[SPOJ2666][ZJOI2007]捉迷藏Query on a tree IV(树链剖分)(论文做法)

　题面

实际上,捉迷藏是Query on a tree IV的简化版。但区别只是捉迷藏的边权全部为1.这里把两个题合并起来写。

给定一棵包含 N 个结点的树，每个节点要么是黑色(亮灯)，要么是白色(不亮灯)。初始时每个节点都是白色。
要求模拟两种操作：
(1)改变某个结点的颜色。
(2)询问最远的两个白色结点之间的距离。

分析

做法来自2009年的国家集训队论文。捉迷藏的标准做法是利用括号序列的性质，但是括号序列是不能在有负边权的树上使用的。另外动态点分治似乎可做，不过论文中指出树链剖分实际上也是一种分治，只不过它的分治子树是一条重链，因此这两种做法本质是相同的

初始化

首先对树进行轻重链剖分。对于每个节点,记(d_1(x))和(d_2(x))分别表示该节点到子树中的白色节点的最长距离和次长距离,且两条路径仅在根节点处相交.如果不存在,则记为(- infin)

对于每条链上的节点,我们要维护以下三个变量:

• (lmax): (x)所在重链的最浅节点到(x)子树中最远白点的距离
• (rmax): (x)所重链的最深节点到(x)子树中最远白点的距离
• (mlen):与(x)所在重链相交的,(x)子树中两个白点中间的路径的最长长度.

因为重链上节点的dfs序是连续的,那么重链对应一个区间([l,r]),记(id_{l})为dfs序为(l)的节点编号,最浅的节点为(id_l),最深的节点为(id_r)。因此我们可以对每条重链开一棵线段树来维护这几个变量。
记(dist(i,j))为(i,j)间距离,(p)为区间([l,r])对应的线段树节点,(lp,rp)为(p)的左右儿子。(mid=frac{l+r}{2}),那么有:
[lmax(p)=max(lmax(lp),dist(id_{mid+1},id_r)+lmax(rp))]
第二项就是把rp对应的一个前缀接到链([l,mid])上
[rmax(p)=max(rmax(rp),rmax(lp)+dist(id_{mid},id_r)]
[mlen(p)=max(mlen(lp),mlen(rp),rmax(lp)+dist(id_{mid},id_{mid+1})+lmax(rp))]

由于是一条链,(dist)可以(O(1))算出。直接在线段树里 push_up即可.

void push_up(int x) {
        int l=tree[x].l,r=tree[x].r,mid=(l+r)>>1;
        tree[x].lmax=max(tree[lson(x)].lmax,dist[hash_dfn[mid+1]]-dist[hash_dfn[l]]+tree[rson(x)].lmax);//注意线段树是按dfs序存的
        tree[x].rmax=max(tree[rson(x)].rmax,dist[hash_dfn[r]]-dist[hash_dfn[mid]]+tree[lson(x)].rmax);
        tree[x].mlen=max(max(tree[lson(x)].mlen,tree[rson(x)].mlen),
                         tree[lson(x)].rmax+dist[hash_dfn[mid+1]]-dist[hash_dfn[mid]]+tree[rson(x)].lmax);
    }

叶子节点的初始值可以这样设置
若(id_p)是黑点,有:
(lmax(p)=rmax(p)=d_1(id_p))
(mlen(p)=d_1(id_p)+d_2(id_p)) 因为(d_1,d_2)保证了交点只有一个,它们可以接起来

若(id_p)是白点,有
(lmax(p)=rmax(p)=max(d_1(id_p),0)) (把自己作为路径结尾,所以和0取max)
(mlen(p)=max(d_1(id_p)+d_2(id_p),d_1(id_p),0))
和 (可以把自己作为路径结尾,也可以两条路接在一起)

(d_1)和(d_2)可以用一个支持插入和删除任意元素的大根堆维护，可以用STL中的multiset实现.每个节点开一个这样的数据结构(h[x]),存储可能的路径长度。 初始化的时候只需遍历(x)的轻儿子(y),用下面一层的重链更新上面的答案,插入(y)的(lmax+dist(x,y))即可。因此建树的时候一定要从深到浅建。

for(int i=head[x]; i; i=E[i].next) {
    int y=E[i].to;
    if(y!=fa[x]&&y!=son[x]){
        h[x].insert(tree[root[top[y]]].lmax+E[i].len);
        //累加下面一层重链的答案 
    }
}

处理查询

类似(d_1)和(d_2),我们维护一个全局的multisetans存储每条重链的答案(链顶lmax)。查询的时候输出最大值

处理修改

修改是最复杂的部分。我们沿着(x)往上跳,修改每一条重链。

(1)要删除当前重链对上方重链的影响,对于链顶节点父亲,我们在(h)中删去当前链顶的lmax+dist.

(2)修改线段树。如果是在被修改节点的重链上，就找到该节点,否则找到重链的最深节点。由于下面的重链已经修改完，我们可以用下面重链更新当前的答案。所以我们要在堆里插入新的(lmax+dist).然后求出新的(d_1,d_2)来更新(lmax,rmax,mlen).接着上推即可。

(3)在(ans)里删除旧的答案(链顶lmax),插入新的答案,

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<set>
#define maxn 100000
#define maxlogn 20
#define INF 0x3f3f3f3f
using namespace std;
int n,m;
struct my_heap { //支持删除任意元素的大根堆
    struct cmp {
        bool operator () (int p,int q) {
            return p>q;
        }
    };
    typedef multiset<int,cmp> hp;
    hp S;
    void insert(int v) {
        S.insert(v);
    }
    void del(int v) {
//      printf("delete %d
",v);
        hp::iterator it=S.lower_bound(v);
        if(it!=S.end()) S.erase(it);
    }
    int top() {
        if(S.empty()) return -INF;
        else return *S.begin();
    }
    int sec() { //
        int fir=top();
        if(fir!=-INF) {
            del(fir);
            int snd=top();
            insert(fir);
            return snd;
        } else return -INF;
    }
} h[maxn+5]/*每个节点到子树中的白点的距离*/,ans/*全局最大堆存储每条链的答案 */;

struct edge {
    int from;
    int to;
    int len;
    int next;
} E[maxn*2+5];
int head[maxn+5];
int esz;
void add_edge(int u,int v,int w) {
    esz++;
    E[esz].from=u;
    E[esz].to=v;
    E[esz].len=w;
    E[esz].next=head[u];
    head[u]=esz;
}

int light[maxn+5];//1为白点,2为黑点 
 
int tim;
int dist[maxn+5];
int sz[maxn+5],fa[maxn+5],son[maxn+5],top[maxn+5],dfn[maxn+5],hash_dfn[maxn+5],len[maxn+5]/*重链长度*/;
void dfs1(int x,int f) {
    sz[x]=1;
    fa[x]=f;
    for(int i=head[x]; i; i=E[i].next) {
        int y=E[i].to;
        if(y!=f) {
            dist[y]=dist[x]+E[i].len;
            dfs1(y,x);
            sz[x]+=sz[y];
            if(sz[y]>sz[son[x]]) son[x]=y;
        }
    }
}
void dfs2(int x,int t) {
    dfn[x]=++tim;
    hash_dfn[dfn[x]]=x;
    top[x]=t;
    len[t]++;
    if(son[x]) dfs2(son[x],t);
    for(int i=head[x]; i; i=E[i].next) {
        int y=E[i].to;
        if(y!=fa[x]&&y!=son[x]) dfs2(y,y);
    }
}
int root[maxn+5];
struct segment_tree {
#define lson(x) (tree[x].ls)
#define rson(x) (tree[x].rs)
    struct node { //由于对每个重链建一棵树,动态开点
        int l;
        int r;
        int ls;
        int rs;
        int lmax;//该节点所在重链的上端到子树中最远白点的距离
        int rmax;//该节点所在重链的下端到子树中最远白点的距离
        int mlen;//与该节点所在重链相交的,子树中两个白点中间的路径的最长长度.
    } tree[maxn*4+5];
    int ptr;
    void push_up(int x) {
        int l=tree[x].l,r=tree[x].r,mid=(l+r)>>1;
        tree[x].lmax=max(tree[lson(x)].lmax,dist[hash_dfn[mid+1]]-dist[hash_dfn[l]]+tree[rson(x)].lmax);//注意线段树是按dfs序存的
        tree[x].rmax=max(tree[rson(x)].rmax,dist[hash_dfn[r]]-dist[hash_dfn[mid]]+tree[lson(x)].rmax);
        tree[x].mlen=max(max(tree[lson(x)].mlen,tree[rson(x)].mlen),
                         tree[lson(x)].rmax+dist[hash_dfn[mid+1]]-dist[hash_dfn[mid]]+tree[rson(x)].lmax);
    }
    void build(int &pos,int l,int r) {
        if(!pos) pos=++ptr;
        tree[pos].l=l;
        tree[pos].r=r;
        if(l==r) {
            int x=hash_dfn[l];
            for(int i=head[x]; i; i=E[i].next) {
                int y=E[i].to;
                if(y!=fa[x]&&y!=son[x]){
                    h[x].insert(tree[root[top[y]]].lmax+E[i].len);
                    //累加下面一层重链的答案 
                }
            }
            int d1=h[x].top();
            int d2=h[x].sec();
            //d1,d2为当前节点x到子树中白点的最大距离和次大距离,保证d1,d2只在x处相交 
            //初始时所有点都是白点,按白点的方法修改 
            tree[pos].lmax=tree[pos].rmax=max(d1,0);
            tree[pos].mlen=max(0,max(d1,d1+d2));
            return;
        }
        int mid=(l+r)>>1;
        build(lson(pos),l,mid);
        build(rson(pos),mid+1,r);
        push_up(pos);
    }
    void update(int pos,int x,int tp) {
        if(tree[pos].l==tree[pos].r) {
            if(x!=tp) h[x].insert(tree[root[tp]].lmax+dist[tp]-dist[x]));//插入新的答案 
            int d1=h[x].top();
            int d2=h[x].sec();
            if(light[x]) { //黑点 
                tree[pos].lmax=tree[pos].rmax=d1;
                tree[pos].mlen=d1+d2;
            } else { //白点 
                tree[pos].lmax=tree[pos].rmax=max(d1,0);//和自己凑成一对,所以和0取max
                tree[pos].mlen=max(0,max(d1,d1+d2));//可以和自己,也可以两条路接在一起
            }
            return;
        }
        int mid=(tree[pos].l+tree[pos].r)>>1;
        if(dfn[x]<=mid) update(lson(pos),x,tp);
        else update(rson(pos),x,tp);
        push_up(pos);
    }
}T;

void change(int x){
    int last=x; 
    while(x){//沿着重链往上跳 
        int tp=top[x];
        int p1=T.tree[root[tp]].mlen;
        if(fa[tp]){
            h[fa[tp]].del(T.tree[root[tp]].lmax+dist[tp]-dist[fa[tp]]);
            //删除当前点对上面重链答案的影响,等到跳到上面重链的时候再用线段树去更新 
        }
        T.update(root[tp],x,last);
        int p2=T.tree[root[tp]].mlen;
        if(p1!=p2){//答案发生改变 
            ans.del(p1);
            ans.insert(p2);
        }
        last=tp;
        x=fa[top[x]];
    }
}
int main() {
    int u,v,w; 
    int cnt=0;
    char op[maxn+5];
    scanf("%d",&n);
    cnt=n;
    for(int i=1;i<n;i++){
        scanf("%d %d %d",&u,&v,&w);
        add_edge(u,v,w);
        add_edge(v,u,w);
    }
    dfs1(1,0);
    dfs2(1,1);
    for(int i=n;i>=1;i--){//按照dfs序倒序,这样可以保证一条链是从下往上的 
        int x=hash_dfn[i];
        if(x==top[x]){
            T.build(root[x],dfn[x],dfn[x]+len[x]-1);
            ans.insert(T.tree[root[x]].mlen);
        }
    }
    scanf("%d",&m);
    for(int i=1;i<=m;i++){
        scanf("%s",op);
        if(op[0]=='C'){
            scanf("%d",&u);
            light[u]^=1;
            if(light[u]==0) cnt++;
            else cnt--;
            change(u); 
        }else{
            if(cnt==0) puts("They have disappeared.");
            else printf("%d
",ans.top());
        }
    }
}
/*
8
1 2 1
2 3 1
3 4 1
3 5 1
3 6 1
6 7 1
6 8 1
7
A
C 1
A
C 2
A
C 1
A
*/