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 >> ) - ;

 typedef class Node {
     public:
         int val;
         Node *l, *r;

         Node(int val = , 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(), rt(NULL), dr(NULL) {        }

         int top() {
             if(!rt)    return -;
             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 < )    return;
             s++;
             rt = merge(rt, newnode(x));
             clr(rt, dr);
         }

         void remove(int x) {
             if(x < )    return;
             s--;
             dr = merge(dr, newnode(x));
             clr(rt, dr);
         }

         int size() {
             return s;
         }
 }Heap;

 const int N = 1e5 + ;

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

 int cerl = ;
 void dfs1(int p, int fa) {
     erl[++cerl] = p;
     in[p] = cerl;
     dep[p] = dep[fa] + ;
     for(int i = ; 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[][N << ];
 inline void init_st() {
     Log2[] = , dep[] = ;
     for(int i = ; i <= n2; i++)
         Log2[i] = Log2[i >> ] + ;
     dfs1(, );

     for(int i = ; i < n2 - ; i++)
         st[][i] = (dep[erl[i]] < dep[erl[i + ]]) ? (erl[i]) : (erl[i + ]);
     for(int j = ; j < bzmax; j++)
         for(int i = , a, b; i + ( << j) < n2; i++) {
             a = st[j - ][i], b = st[j - ][i + ( << (j - ))];
             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 + ];
     a = st[len][l], b = st[len][r - ( << len) + ];
     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] << );
 }

 void dfs2(int p, int fa) {
     siz[p] = ;
     for(int i = ; 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 = ; 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 = ; i < (signed)g[p].size(); i++) {
         int e = g[p][i];
         if(e == fa || vis[e])    continue;
         dfs4(e, p, dep + , 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, );
     int G, maxv = inf, sG;
     dfs3(p, , siz[p], G, maxv);
     vis[G] = true, ::fag[G] = fag;
     dfs4(G, , , G, fag);
     dtg[G].insert();
     for(int i = ; 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 = , newt = -;
     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 = -, newt = ;
     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[];
     int x;
     while (m--) {
         scanf("%s", buf);
         if(buf[] == '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(, );
     solve();
     return ;
 }