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

HINT

对于100%的数据， N ≤100000, M ≤500000。

思路

首先来了解一下括号序列怎么生成

void dfs(int u, int fa) {

  c[++ind] = '(';

  c[++ind] = (char) (u + '0' - 1);

  for (int i = head[u]; i; i = E[i].nxt) {

    int v = E[i].v;

    if (v == fa) continue;

    dfs(v, u);

  }

  c[++ind] = ')';

}

这样就得到了一个括号序列

比如样例中的序列就是$(1(2(3(6(8)(7))(5)(4))))$

然后如果把数字去掉，就发现这个序列变成了$((((()())()())))$

其实可以简单理解为$($是向下，$)$是向上那么我们如何利用这个信息

如果我们要计算两点的距离，先把这两点之间的括号序列提取出来

比如说8和4，括号序列是$)())()($，消除掉中间可以匹配的括号变成$))($

这就说明8到4只需要上行两次下行一次，至于中间的匹配括号实际上是一上一下全部抵消了

所以我们就可以简单知道8和4的路径是3

那么我们实际上需要求的是树上两个黑点之间的最长距离

把化简过后的括号序列表示出来，$S(a,b)$表示有a个$)$和b个$($组成的括号序列

考虑怎么合并$S_1(a_1,b_1)$和$S_2(a_2,b_2)$

首先可以知道中间匹配掉的括号有$\min(b_1,a_2)$个

那么分情况讨论（接下来的所有讨论中都默认自动化简括号序列）

如果$a_2\le b_1$， $S(a_1-a_2+b_1,b_2),len=a_1+b_1-a_2+b_2$
反之，$S(a_1,b_2-b_1+a_2),len=a_1-b_1+a_2+b_2$

把1的左右两边的贡献拆开看，发现左边的贡献是$a_1+b_1$，右边贡献是$-a_2+b_2$

把2的左右两边的贡献拆开看，发现左边的贡献是$a_1-b_1$，右边贡献是$a_2+b_2$

于是我们需要维护的就变成了

$l_{add}$：区间所有前缀最大的$a+b$
$l_{sub}$：区间所有前缀最大的$b - a$
$r_{add}$：区间所有后缀最大的$a+b$
$r_{sub}$：区间所有后缀最大的$a-b$

同时记录$l_{len}$表示区间左边一部分括号的长度，$r_{len}$表示区间右边一部分括号的长度

记$maxdis$是区间中的左右括号的最大长度（答案）

先倒着看怎么更新$maxdis$，分成左右两边和跨过中间的两部分来算

\[maxdis=\max(ld.maxdis,rd.maxdis,ld.r_{add}+rd.l_{sub},ld.r_{sub}+rd.l_{add})
\]

后面的两个式子就是根据上面推导出来的式子进行更新的

然后看一看$l_{len}$和$r_{len}$，更新比较简单，直接分情况进行讨论就可以了

如果$ld.r_{len} >= rd.l_{len}$

\[t.l_{len} = ld.l_{len}
\\
t.r_{len} = rd.r_{len} + ld.r_{len} - rd.l_{len}
\]

反之

\[t.l_{len} = ld.l_{len} + rd.l_{len} - ld.r_{len}
\\
t.r_{len} = rd.r_{len}
\]

接下来就是对$l_{add},l_{sub},r_{add},r_{sub}$的更新了

在这里为了避免冗余的描述，默认情况1是ld用来合并的右区间长度大于等于rd用来合并的左区间长度，2是相反的情况

同时一切都在

$S(a_1,b_1 + b_2-a_2)$
$S(a_1+a_2-b_1,b_2)$

的情况上展开叙述

更新$l_{add}$
1. $a+b=a_1+b_1-a_2+b_2=ld.l_{len} + ld.r_{len} + rd.l_{sub}$
2. $a+b=a_1-b_1+a_2+b_2=ld.l_{len} - ld.r_{len} + rd.l_{add}$
所以总的式子是：

\[l_{add} = \max(ld.l_{add}, ld.l_{len} + ld.r_{len} + rd.l_{sub},ld.l_{len} - ld.r_{len} + rd.l_{add})
\]

更新$l_{sub}$

因为经过推导发现，无论是1还是2，最后表示出来的$b-a$都是$-a_1+b_1-a_2+b_2=- ld.l_{len}+ ld.r_{len} + rd.l_{sub}$

所以式子是：

\[l_{sub} = \max(ld.l_{sub}, - ld.l_{len}+ ld.r_{len} + rd.l_{sub})
\]
更新$r_{add}$
1. $a+b=a_1+b_1-a_2+b_2=ld.r_{add}-rd.l_{len} + rd.r_{len}$
2. $a+b=a_1-b_1+a_2+b_2=ld.r_{sub}+rd.l_{len}+rd.r_{len}$
总的式子：

\[r_{add} = \max(rd.r_{add}, ld.r_{add} - rd.l_{len} + rd.r_{len}, ld.r_{sub} + rd.l_{len} + rd.r_{len})
\]
更新$r_{sub}$

发现无论最后表示出来的式子一定是$a-b=a_1-b_1+a_2-b_2=ld.r_{sub} + rd.l_{len} - rd.r_{len}$

总的式子是：

\[r_{sub} = \max(rd.r_{sub}, ld.r_{sub} + rd.l_{len} - rd.r_{len})
\]

我们现在知道怎么维护括号序列了，但是还有一个问题，就是$r_{len},l_{add},l_{sub}$的右端点，$l_{len},r_{add},r_{sub}$的左端点都需要有黑点才成立

那么还是偷懒直接把点带进去维护好了

于是初值就可以这样设定，为了满足端点必须有黑点的限制，我们只在当前节点代表一个黑点的时候把$l_{add},l_{sub},r_{add},r_{sub}$赋值成$0$，否则就把这四个值都设成$-\infty $

然后如果当前节点是右括号，就把$l_{len}$设成1,

如果当前节点是左括号，就把$r_{len}$设成1就可以了

完结撒花

总结

很好的一道题，就是pushup函数写起来有些自闭，用括号序列压缩的方法把树的形态表示了出来，非常的巧妙，而且比动态点分治的做法快了许多，写的时候就是写初始化函数的时候没有引用，导致出现了一系列问题，下次注意好了，这道题的思维方式还是很值得借鉴的

#include<bits/stdc++.h>

using namespace std;

const int INF_of_int = 1e9;

const int N = 3e5 + 10;

const int M = N << 2;

struct Edge {

  int v, nxt;

} E[N << 1];

int head[N], tot = 0;

int n, q, num = 0, ind = 0, pre[N], typ[N], col[N], dfn[N];

char c[10];

//typ -1:')' 1:'(' 0:col

void addedge(int u, int v) {

  E[++tot] = (Edge) {v, head[u]};

  head[u] = tot;

}

void dfs(int u, int fa) {

  typ[++ind] = 1;

  typ[++ind] = 0;

  dfn[u] = ind;

  pre[ind] = u;

  col[u] = 1;

  for (int i = head[u]; i; i = E[i].nxt) {

    int v = E[i].v;

    if (v == fa) continue;

    dfs(v, u);

  }

  typ[++ind] = -1;

}

#define LD (t << 1)

#define RD (t << 1 | 1)

struct Node {

  int maxdis, l_len, r_len;

  int l_add, r_add, l_sub, r_sub;

} p[M];

void init(Node &t, int pos) {

  t.maxdis = -INF_of_int;

  t.l_len = t.r_len = 0;

  if (typ[pos] != 0) {

    if (typ[pos] > 0) t.r_len = 1;

    if (typ[pos] < 0) t.l_len = 1;

    t.l_add = t.r_add = t.l_sub = t.r_sub = -INF_of_int;

  } else {

    if (col[pre[pos]]) t.l_add = t.r_add = t.l_sub = t.r_sub = 0;

    else t.l_add = t.r_add = t.l_sub = t.r_sub = -INF_of_int;

  }

}

Node pushup(Node ld, Node rd) {

  Node t;

  t.maxdis = max(max(ld.maxdis, rd.maxdis), max(ld.r_add + rd.l_sub, ld.r_sub + rd.l_add));

  t.l_add = max(ld.l_add, max(ld.l_len - ld.r_len + rd.l_add, ld.l_len + ld.r_len + rd.l_sub));

  t.l_sub = max(ld.l_sub, ld.r_len - ld.l_len + rd.l_sub);

  t.r_add = max(rd.r_add, max(ld.r_add - rd.l_len + rd.r_len, ld.r_sub + rd.l_len + rd.r_len));

  t.r_sub = max(rd.r_sub, ld.r_sub + rd.l_len - rd.r_len);

  if (ld.r_len >= rd.l_len) t.l_len = ld.l_len, t.r_len = rd.r_len + ld.r_len - rd.l_len;

  else t.l_len = ld.l_len + rd.l_len - ld.r_len, t.r_len = rd.r_len;

  return t;

}

void build(int t, int l, int r) {

  if (l == r) {

    init(p[t], l);

    return;

  }

  int mid = (l + r) >> 1;

  build(LD, l, mid);

  build(RD, mid + 1, r);

  p[t] = pushup(p[LD], p[RD]);

}

void modify(int t, int l, int r, int pos) {

  if (l == r) {

    init(p[t], l);

    return;

  }

  int mid = (l + r) >> 1;

  if (pos <= mid) modify(LD, l, mid, pos);

  else modify(RD, mid + 1, r, pos);

  p[t] = pushup(p[LD], p[RD]);

}

int main() {

#ifdef dream_maker

  freopen("input.txt", "r", stdin);

#endif

  scanf("%d", &n);

  for (int i = 2; i <= n; i++) {

    int u, v; scanf("%d %d", &u, &v);

    addedge(u, v);

    addedge(v, u);

  }

  dfs(1, 0);

  num = n;

  build(1, 1, ind);

  scanf("%d", &q);

  while (q--) {

    scanf("%s", c);

    if (c[0] == 'C') {

      int u; scanf("%d", &u);

      if (col[u]) --num;

      else ++num;

      col[u] ^= 1;

      modify(1, 1, ind, dfn[u]);

    } else {

      if (num == 0) printf("-1\n");

      else if (num == 1) printf("0\n");

      else printf("%d\n", p[1].maxdis);

    }

  }

  return 0;

}