bzoj 1095 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。

---

题目大意

给定一棵树，每个点的颜色不是黑色就是白色，开始所有点的颜色都是黑色，要求支持两个操作：

1. 翻转一个点的颜色
2. 询问最远的黑点对的距离。如果只有1个黑点，那么输出0，如果没有黑点，输出-1。

　　由于有多次询问，所以不可能暴力求最长链。

　　如何快速处理最长链？于是想到了点分治。

　　现在的任务是让点分治支持修改操作。

　　因为最长距离不可加减，所以只能通过维护分治中心的各子树中，深度最大的点，然后取前两大更新答案。

　　因此，每个点维护两个堆，一个堆维护点分树上它的子树中深度最大的点的深度，一个堆维护在点分树上它的子树中所有点到它的父分治中心的距离。

　　除此之外，还要开一个全局堆维护答案。

　　对于修改操作，就是删除元素再插入元素，自己画画图就能想清楚（明明是yyf扯不清楚）。

　　问题是怎么让堆支持删除？再开个堆打标记就好了。

　　还有一个问题，如何求树上两点间的距离？两点的深度减去它们LCA的深度的两倍，求LCA用st表。

Code

/**
 * bzoj
 * Problem#1095
 * Accepted
 * Time: 13356ms
 * Memory: 159584k
 */ 
#include <bits/stdc++.h>
using namespace std;
typedef bool boolean;
const signed int inf = (signed) (~0u >> 1) - 1;

typedef class Node {
    public:
        int val;
        Node *l, *r;
        
        Node(int val = 0, Node* l = NULL, Node* r = NULL):val(val), l(l), r(r) {        }
}Node;

Node* merge(Node* a, Node* b) {
    if(!a)    return b;
    if(!b)    return a;
    if(a->val < b->val)    swap(a, b);
    a->r = merge(a->r, b);
    swap(a->l, a->r);
    return a;
}

#define Limit 10000000
Node pool[Limit];
Node *top = pool;

Node* newnode(int x) {
    if(top >= pool + Limit)
        return new Node(x, NULL, NULL);
    top->val = x;
    return top++;
}

#define clr(rt, dr) while(rt && dr && dr->val == rt->val)    rt = merge(rt->l, rt->r), dr = merge(dr->l, dr->r)
typedef class Heap {
    public:
        int s;
        Node* rt;
        Node* dr;
        
        Heap():s(0), rt(NULL), dr(NULL) {        }
        
        int top() {
            if(!rt)    return -1;
            return rt->val;
        }
        
        int sectop() {
            if(!rt)    return -inf;
            clr(rt->l, dr);
            clr(rt->r, dr);
            int lv = (rt->l) ? (rt->l->val) : (-inf), rv = (rt->r) ? (rt->r->val) : (-inf);
            return (lv > rv) ? (lv) : (rv);
        }
        
        void pop() {
            rt = merge(rt->l, rt->r);
            clr(rt, dr);
        }
        
        void insert(int x) {
            if(x < 0)    return;
            s++;
            rt = merge(rt, newnode(x));
            clr(rt, dr);
        }
        
        void remove(int x) {
            if(x < 0)    return;
            s--;
            dr = merge(dr, newnode(x));
            clr(rt, dr);
        }
        
        int size() {
            return s;
        }
}Heap;

const int N = 1e5 + 5;

int n, m, n2;
vector<int> *g;
Heap *dtg, *dtf, gol; 
int *siz, *fag, *dep, *erl;
int *Log2, *in;
boolean *vis, *ison;

inline void init() {
    scanf("%d", &n), n2 = n << 1;
    g = new vector<int>[(n + 1)];
    dtg = new Heap[(n + 1)];
    dtf = new Heap[(n + 1)];
    in = new int[(n + 1)];
    siz = new int[(n + 1)];
    fag = new int[(n + 1)];
    dep = new int[(n + 1)];
    erl = new int[(n2 + 1)];
    Log2 = new int[(n2 + 1)];
    vis = new boolean[(n + 1)];
    ison = new boolean[(n + 1)];
    fill(vis + 1, vis + n + 1, false);
    fill(ison + 1, ison + n + 1, false);
    for(int i = 1, u, v; i < n; i++) {
        scanf("%d%d", &u, &v);
        g[u].push_back(v);
        g[v].push_back(u);
    }
}

int cerl = 0;
void dfs1(int p, int fa) {
    erl[++cerl] = p;
    in[p] = cerl;
    dep[p] = dep[fa] + 1;
    for(int i = 0; i < (signed)g[p].size(); i++) {
        int e = g[p][i];
        if(e == fa)    continue;
        dfs1(e, p);
        erl[++cerl] = p;
    }
}

#define bzmax 19
int st[19][N << 1];
inline void init_st() {
    Log2[1] = 0, dep[0] = 0;
    for(int i = 2; i <= n2; i++)
        Log2[i] = Log2[i >> 1] + 1;
    dfs1(1, 0);
    
    for(int i = 1; i < n2 - 1; i++)
        st[0][i] = (dep[erl[i]] < dep[erl[i + 1]]) ? (erl[i]) : (erl[i + 1]);
    for(int j = 1; j < bzmax; j++)
        for(int i = 1, a, b; i + (1 << j) < n2; i++) {
            a = st[j - 1][i], b = st[j - 1][i + (1 << (j - 1))];
            st[j][i] = (dep[a] < dep[b]) ? (a) : (b);
        }
}

inline int Lca(int u, int v) {
    int l = in[u], r = in[v], len, a, b;
    if(l > r)    swap(l, r);
    len = Log2[r - l + 1];
    a = st[len][l], b = st[len][r - (1 << len) + 1];
    return (dep[a] < dep[b]) ? (a) : (b);
}

inline int dist(int u, int v) {
    int lca = Lca(u, v);
    return dep[u] + dep[v] - (dep[lca] << 1);
}

void dfs2(int p, int fa) {
    siz[p] = 1;
    for(int i = 0; i < (signed)g[p].size(); i++) {
        int e = g[p][i];
        if(e == fa || vis[e])    continue;
        dfs2(e, p);
        siz[p] += siz[e];
    }
}

void dfs3(int p, int fa, int& cov, int& G, int& maxv) {
    int cmp = cov - siz[p];
    for(int i = 0; i < (signed)g[p].size(); i++) {
        int e = g[p][i];
        if(e == fa || vis[e])    continue;
        dfs3(e, p, cov, G, maxv);
        cmp = (siz[e] > cmp) ? (siz[e]) : (cmp);
    }
    if(cmp < maxv)
        maxv = cmp, G = p;
}

void dfs4(int p, int fa, int dep, int G, int fG) {
    if(fG)    dtf[G].insert(dist(p, fG));
    for(int i = 0; i < (signed)g[p].size(); i++) {
        int e = g[p][i];
        if(e == fa || vis[e])    continue;
        dfs4(e, p, dep + 1, G, fG);
    }
}

#define get_val(h)    (h.size() <= 1) ? ((h.size() == 1) ? (0) : (-1)) : (h.top() + h.sectop())
int dividing(int p, int fag) {
    dfs2(p, 0);
    int G, maxv = inf, sG;
    dfs3(p, 0, siz[p], G, maxv);
    vis[G] = true, ::fag[G] = fag;
    dfs4(G, 0, 0, G, fag);
    dtg[G].insert(0);
    for(int i = 0; i < (signed)g[G].size(); i++) {
        int e = g[G][i];
        if(vis[e])    continue;
        sG = dividing(e, G);
        dtg[G].insert(dtf[sG].top());
    }
    gol.insert(get_val(dtg[G]));
    return G;
}

void turn_on(int p) {
    int G = p, oldt = 0, newt = -1;
    ison[p] = true;
    while (G) {
        if(oldt != newt) {
            gol.remove(get_val(dtg[G]));
            dtg[G].remove(oldt);
            if(~newt)    dtg[G].insert(newt);
            gol.insert(get_val(dtg[G]));
        }
        if (fag[G]) {
            oldt = dtf[G].top();
            dtf[G].remove(dist(p, fag[G]));
            newt = dtf[G].top();
        }
        G = fag[G];
    }
}

void turn_off(int p) {
    int G = p, oldt = -1, newt = 0;
    ison[p] = false;
    while (G) {
        if(oldt != newt) {
            gol.remove(get_val(dtg[G]));
            if(~oldt)    dtg[G].remove(oldt);
            dtg[G].insert(newt);
            gol.insert(get_val(dtg[G]));
        }
        if(fag[G]) {
            oldt = dtf[G].top();
            dtf[G].insert(dist(p, fag[G]));
            newt = dtf[G].top();
        }
        G = fag[G];
    }
}

inline void solve() {
    scanf("%d", &m);
    char buf[10];
    int x;
    while (m--) {
        scanf("%s", buf);
        if(buf[0] == 'G') {
            int x = gol.top();
            printf("%d\n", x);
        } else {
            scanf("%d", &x);
            if(ison[x])
                turn_off(x);
            else
                turn_on(x);
        }
    }
}

int main() {
    init();
    init_st();
    dividing(1, 0);
    solve();
    return 0;
}