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。

---

Solution

• 感觉是个神题，动态点分治什么的太弱并不会啊。
• 线段树做法也主要靠脑补……
• 具体先丢个别人的网址。
• 考虑对原树 $DFS$，到达点 $x$ 时往序列尾部添加一个左括号和点 $x$，遍历完以 $x$ 为根的子树后再往序列尾部添加一个右括号，最后我们会得到一个括号序列。
• 这样的括号序列有个神奇的性质：树上两点的距离（边权均为1）等于括号序列中两点间去掉所有匹配的括号后剩余的括号数。
• 其实也很显然，因为树上连接两点的路径上挂着的子树都是以成对的括号出现，去掉后就只剩这条路径了。
• 这样我们就可以用线段树来维护这个序列了。

• 考虑对线段树上维护7个值（均在已经去掉匹配括号的情况下）：

  1. $s_1$：”(“的个数。
  2. $s_2$：”)”的个数。
  3. $l_1$：某黑点到该区间左端点”(“个数与”)”个数之和最大值。
  4. $r_1$：某黑点到该区间右端点”(“个数与”)”个数之和最大值。
  5. $l_2$：某黑点到该区间左端点”(“个数与”)”个数之差最大值。
  6. $r_2$：某黑点到该区间右端点”)”个数与”(“个数之差最大值。
  7. $ans$：该区间任意两黑点之间去匹配括号后”(“个数与”)”个数之和的最大值。

  8. 那么具体的维护就为（仿佛理解了很久）：

// l,r 分别为 x 的左右区间
x.s1=r.s1+max(l.s1-r.s2,0); //若左区间的"("被右区间的")"抵消完要取0
x.s2=l.s2+max(r.s2-l.s1,0); //若右区间的")"被左区间的"("抵消完要取0
x.l1=max(l.l1,
max(l.s1+l.s2+r.l2,  //当右区间的")"被左区间的"("抵消完时 
    l.s2+r.l1-l.s1));//当左区间的"("被右区间的")"抵消完时

x.r1=max(r.r1,
max(r.s1+r.s2+l.r2,  //当左区间的"("被右区间的")"抵消完时
    r.s1+l.r1-r.s2));//当右区间的")"被左区间的"("抵消完时

x.l2=max(l.l2,r.l2+l.s1-l.s2); 
x.r2=max(r.r2,l.r2+r.s2-r.s1);
x.ans=max(max(l.ans,r.ans),
      max(l.r1+r.l2,   //当右区间的")"被左区间的"("抵消完时
          r.l1+l.r2)); //当左区间的"("被右区间的")"抵消完时

• 如果要把黑点改为白点，就把除 $s_1, s_2$ 的其余信息都赋为无穷小，就不会对答案有影响了，改回来也是类似。
• 时间复杂度 $O(n \log n)$。

Code

#include <iostream>
#include <cstdio>
#include <cctype>
#include <algorithm>
#include <cstring>

using namespace std;

namespace inout
{
    const int S = 1 << 20;
    char frd[S], *ihed = frd + S;
    const char *ital = ihed;

    inline char inChar()
    {
        if (ihed == ital)
            fread(frd, 1, S, stdin), ihed = frd;
        return *ihed++;
    }

    inline int get()
    {
        char ch; int res = 0; bool flag = false;
        while (!isdigit(ch = inChar()) && ch != '-');
        (ch == '-' ? flag = true : res = ch ^ 48);
        while (isdigit(ch = inChar()))
            res = res * 10 + ch - 48;
        return flag ? -res : res; 
    }

    char fwt[S], *ohed = fwt;
    const char *otal = ohed + S;

    inline char outChar(char ch)
    {
        if (ohed == otal)
            fwrite(fwt, 1, S, stdout), ohed = fwt;
        return *ohed++ = ch;
    }

    inline void put(int x)
    {
        if (x > 9) put(x / 10);
        outChar(x % 10 + 48);
    }
};
using namespace inout;

const int N = 1e5 + 5, M = N * 3;
const int Minn = -0x3f3f3f3f;

int dfn[M], pos[N], L, n, m;

struct node
{
    int s1, s2, l1, r1, l2, r2, ans;

    inline void Change(int x)
    {
        l1 = r1 = l2 = r2 = ans = x;
    }
}a[M << 2];

struct Edge 
{
    int to; Edge *nxt;
}p[N << 1], *T = p, *lst[N];

inline void Link(int x, int y)
{
    (++T)->nxt = lst[x]; lst[x] = T; T->to = y;
    (++T)->nxt = lst[y]; lst[y] = T; T->to = x;
}

inline int Max(int x, int y) {return x > y ? x : y;}

inline void Dfs(int x, int fa)
{
    dfn[++L] = -1;
    dfn[pos[x] = ++L] = 1;
    for (Edge *e = lst[x]; e; e = e->nxt)
    {
        int y = e->to;
        if (y == fa) continue;
        Dfs(y, x);
    }
    dfn[++L] = -2;
}

#define sL s << 1
#define sR s << 1 | 1

inline void Uptdate(int s)
{
    node l = a[sL], r = a[sR];
    a[s].s1 = r.s1 + Max(l.s1 - r.s2, 0);
    a[s].s2 = l.s2 + Max(r.s2 - l.s1, 0);
    a[s].l1 = Max(l.l1, Max(l.s1 + l.s2 + r.l2, l.s2 + r.l1 - l.s1));
    a[s].r1 = Max(r.r1, Max(r.s1 + r.s2 + l.r2, r.s1 + l.r1 - r.s2));
    a[s].l2 = Max(l.l2, r.l2 + l.s1 - l.s2);
    a[s].r2 = Max(r.r2, l.r2 + r.s2 - r.s1);
    a[s].ans = Max(Max(l.ans, r.ans), Max(l.r1 + r.l2, l.r2 + r.l1));
}

inline void Build(int s, int l, int r)
{
    if (l == r)
    {
        a[s].Change(dfn[l] > 0 ? 0 : Minn);
        if (dfn[l] == -1) 
            a[s].s1 = 1;
        else if (dfn[l] == -2)
            a[s].s2 = 1;
        return ;
    }

    int mid = l + r >> 1;
    Build(sL, l, mid); Build(sR, mid + 1, r);
    Uptdate(s); 
}

inline void Modify(int s, int l, int r, int x)
{
    if (l == r) 
        return a[s].Change(a[s].ans == Minn ? 0 : Minn);

    int mid = l + r >> 1;
    if (x <= mid) 
        Modify(sL, l, mid, x);
    else
        Modify(sR, mid + 1, r, x);
    Uptdate(s);  
}

int main()
{
//  freopen("hide.in", "r", stdin);
//  freopen("hide.out", "w", stdout);

    n = get();
    for (int i = 1; i < n; ++i) Link(get(), get());
    Dfs(1, 0); Build(1, 1, L);

    m = get(); char ch;
    while (m--)
    {
        while (ch = inChar(), ch != 'C' && ch != 'G');
        if (ch == 'C') 
            Modify(1, 1, L, pos[get()]);
        else
        {
            if (a[1].ans == Minn) puts("-1");
                else put(a[1].ans), outChar('\n'); 
        }
    }
    fwrite(fwt, 1, ohed - fwt, stdout);

//  fclose(stdin); fclose(stdout);
    return 0;
}