BZOJ3553 [Shoi2014]三叉神经树

容易想到树链剖分来维护

一条链上维护儿子中是1的个数为1的点的最长值和儿子是1的个数为2的点的最长值

于是每次修改的时候就二分查询会更新到哪里，再直接链修改就好了

单次查询复杂度$O(logn^2)$，单次修改复杂度为$O(logn)$

注意如果动态开点太多会导致MLE，最后解决办法是在每个线段树节点上增加了一个res变量表示返回值

 

/**************************************************************
    Problem: 3553
    User: rausen
    Language: C++
    Result: Accepted
    Time:18880 ms
    Memory:102672 kb
****************************************************************/
 
#include <cstdio>
 
using namespace std;
const int N = 5e5 + 5;
 
inline int read();
 
int n;
int seq[N * 3];
 
struct tree_node {
    int v, dep, sz;
    int son[3], fa, top, w;
} tr[N * 3];
 
struct seg {
    seg *ls, *rs, *res;
    int tag, mx[2], sz;
 
    #define Len (1 << 16)
    inline void* operator new (size_t) {
        static seg *mempool, *c;
        if (c == mempool)
            mempool = (c = new seg[Len]) + Len;
        c -> ls = c -> rs = c -> res = NULL;
        c -> tag = -1, c -> sz = 1, c -> mx[0] = c -> mx[1] = 0;
        return c++;
    }
    #undef Len
 
    inline void fill(int x) {
        tag = x;
        mx[0] = mx[1] = 0;
        if (tag == 1) mx[0] = sz;
        if (tag == 2) mx[1] = sz;
    }   
    inline void push() {
        if (tag != -1) {
            if (ls) ls -> fill(tag);
            if (rs) rs -> fill(tag);
            tag = -1;
        }
    }
    inline void update(seg *t1, seg *t2) {
        sz = t1 -> sz + t2 -> sz;
        mx[0] = t2 -> mx[0] + (t2 -> mx[0] == t2 -> sz ? t1 -> mx[0] : 0);
        mx[1] = t2 -> mx[1] + (t2 -> mx[1] == t2 -> sz ? t1 -> mx[1] : 0);
    }
     
    #define mid (l + r >> 1)
    void build(int l, int r) {
        if (l == r) {
            fill(tr[seq[l]].v);
            return;
        }
        ls = new()seg, rs = new()seg, res = new()seg;
        ls -> build(l, mid), rs -> build(mid + 1, r);
        update(ls, rs);
    }
     
    void modify(int l, int r, int L, int R, int d) {
        if (L <= l && r <= R) {
            fill(d);
            return;
        }
        push();
        if (L <= mid) ls -> modify(l, mid, L, R, d);
        if (mid < R) rs -> modify(mid + 1, r, L, R, d);
        update(ls, rs);
    }
     
    int query(int l, int r, int pos) {
        if (l == r) return tag;
        push();
        if (pos <= mid) return ls -> query(l, mid, pos);
        else return rs -> query(mid + 1, r, pos);
    }
    seg* query(int l, int r, int L, int R) {
        if (L <= l && r <= R) return this;
        push();
        if (R <= mid) return ls -> query(l, mid, L, R);
        if (mid < L) return rs -> query(mid + 1, r, L, R);
        res -> update(ls -> query(l, mid, L, R), rs -> query(mid + 1, r, L, R));
        return res;
    }
    #undef mid
} *T;
 
inline void modify(int p, int tar, int c) {
    while (tr[p].top != tr[tar].top)
        T -> modify(1, n, tr[tr[p].top].w, tr[p].w, c), p = tr[tr[p].top].fa;
    T -> modify(1, n, tr[tar].w, tr[p].w, c);
}
 
int change(int p) {
    static int c, now, q;
    static seg *tmp;
    c = tr[p].v, now = tr[p].fa, tr[p].v = 1 - tr[p].v;
    while (1) {
        tmp = T -> query(1, n, tr[tr[now].top].w, tr[now].w);
        if (tmp -> sz != tmp -> mx[c]) break;
        now = tr[now].top;
        if (!tr[now].fa || T -> query(1, n, tr[tr[now].fa].w) != c + 1) break;
        now = tr[now].fa;
    }
    if (T -> query(1, n, tr[now].w) != c + 1) {
        T -> modify(1, n, tr[now].w, tr[now].w, T -> query(1, n, tr[now].w) + (c ? -1 : 1));
        return T -> query(1, n, 1) >= 2;
    }
    if (now == tr[now].top) q = now;
    else q = seq[tr[now].w - T -> query(1, n, tr[tr[now].top].w, tr[now].w) -> mx[c] + 1];
    modify(tr[p].fa, q, tr[p].v + 1);
    if (tr[q].fa) T -> modify(1, n, tr[tr[q].fa].w, tr[tr[q].fa].w, T -> query(1, n, tr[tr[q].fa].w) + (c ? -1 : 1));
    return T -> query(1, n, 1) >= 2;
}
 
void get_seq() {
    static int i, j, q[N], tot_q, tot_d, p, S;
    q[tot_q = 1] = 1, tr[1].fa = 0;
    for (i = 1; i <= n; ++i)
        for (j = 0; j < 3; ++j)
            if (tr[q[i]].son[j] <= n)
                tr[q[++tot_q] = tr[q[i]].son[j]].dep = tr[q[i]].dep + 1;
    for (i = 1; i <= n; ++i) tr[i].top = i, tr[i].sz = 1;
    for (i = n; i; --i) tr[tr[q[i]].fa].sz += tr[q[i]].sz;
     
    tr[0].sz = 0, tr[1].w = 1;
    for (i = 1; i <= n; ++i) {
        p = q[i], tot_d = tr[p].w;
        for (j = S = 0; j < 3; ++j)
            if (tr[p].son[j] <= n && tr[tr[p].son[j]].sz > tr[S].sz)
                S = tr[p].son[j];
        if (S)
            tr[S].w = tot_d + 1, tot_d += tr[S].sz, tr[S].top = tr[p].top;
        for (j = 0; j < 3; ++j)
            if (tr[p].son[j] <= n && tr[p].son[j] != S)
                tr[tr[p].son[j]].w = tot_d + 1, tot_d += tr[tr[p].son[j]].sz;
    }
    for (i = n; i; --i) if (tr[q[i]].v >= 2) ++tr[tr[q[i]].fa].v;
    for (i = 1; i <= n; ++i) seq[tr[i].w] = i;
}
 
int main() {
    int i, j, Q;
    n = read();
    for (i = 1; i <= n; ++i)
        for (j = 0; j < 3; ++j)
            tr[tr[i].son[j] = read()].fa = i;
    for (i = n + 1; i <= 3 * n + 1; ++i)
        tr[tr[i].fa].v += (tr[i].v = read());
    get_seq();
    T = new()seg, T -> build(1, n);
    Q = read();
    while (Q--)
        printf("%d\n", change(read()));
    return 0;
}
 
inline int read() {
    static int x;
    static char ch;
    x = 0, ch = getchar();
    while (ch < '0' || '9' < ch)
        ch = getchar();
    while ('0' <= ch && ch <= '9') {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
    return x;
}

(p.s. 论编程能力弱的后果。。。写了一下午，调了一晚上QAQQQ)