P3703 [SDOI2017]树点涂色

P3703 [SDOI2017]树点涂色

链接

分析：

　　首先对于询问，感觉是线段树维护dfs序，每个点记录到根的颜色个数。第二问差分，第三问区间取max。

　　那么考虑修改，每次将一个点的颜色变成和父节点的颜色一样的过程中，这个点的子树内都会-1。

　　这个修改的过程我们可以认为是修改边的过程，将一些边设为1，一些边设为0，那么一次修改对于一个点就是将原来1的边设为0，现在的边设为1。

　　1和0类似lct中实边与虚边，所以可以lct维护当前那些边是1，那些是0。

　　感觉跟个暴力似的，但是lct中access的操作是log的，所以修改的复杂度是log的，线段树中再有一个log，总复杂度是$O(nlog^2)$

代码：

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
#include<cmath>
#include<cctype>
#include<set>
#include<queue>
#include<vector>
#include<map>
#define Root 1, n, 1
#define lson l, mid, rt << 1
#define rson mid + 1, r, rt << 1 | 1
using namespace std;
typedef long long LL;

inline int read() {
    int x=,f=;char ch=getchar();for(;!isdigit(ch);ch=getchar())if(ch=='-')f=-;
    for(;isdigit(ch);ch=getchar())x=x*+ch-'';return x*f;
}

const int N = , Log = ;
struct Edge{ int to, nxt; } e[N << ];
int head[N], f[N][], siz[N], pos[N], deth[N], Index, En, n, m;

inline void add_edge(int u,int v) {
    ++En; e[En].to = v, e[En].nxt = head[u]; head[u] = En;
    ++En; e[En].to = u, e[En].nxt = head[v]; head[v] = En;
}
void dfs(int u) {
    pos[u] = ++Index; siz[u] = ; deth[u] = deth[f[u][]] + ;
    for (int i = head[u]; i; i = e[i].nxt) {
        int v = e[i].to;
        if (v == f[u][]) continue;
        f[v][] = u;
        dfs(v);
        siz[u] += siz[v];
    }
}
int LCA(int u,int v) {
    if (deth[u] < deth[v]) swap(u, v);
    int d = deth[u] - deth[v];
    for (int j = Log; ~j; --j)
        if ((d >> j) & ) u = f[u][j];
    if (u == v) return u;
    for (int j = Log; ~j; --j)
        if (f[u][j] != f[v][j]) u = f[u][j], v = f[v][j];
    return f[u][];
}
struct SegmentTree{
    int mx[N << ], tag[N << ];
    inline void pushup(int rt) { mx[rt] = max(mx[rt << ], mx[rt <<  | ]); }
    inline void pushdown(int rt) {
        mx[rt << ] += tag[rt]; mx[rt <<  | ] += tag[rt];
        tag[rt << ] += tag[rt]; tag[rt <<  | ] += tag[rt];
        tag[rt] = ;
    }
    void update(int l,int r,int rt,int L,int R,int v) {
        if (L <= l && r <= R) { tag[rt] += v; mx[rt] += v; return ; }
        if (tag[rt]) pushdown(rt);
        int mid = (l + r) >> ;
        if (L <= mid) update(lson, L, R, v);
        if (R > mid) update(rson, L, R, v);
        pushup(rt);
    }
    int query(int l,int r,int rt,int L,int R) {
        if (L <= l && r <= R) return mx[rt];
        if (tag[rt]) pushdown(rt);
        int mid = (l + r) >> ;
        if (R <= mid) return query(lson, L, R);
        else if (L > mid) return query(rson, L, R);
        else return max(query(lson, L, R), query(rson, L, R));
    }
    void pr(int l,int r,int rt) {
        if (l == r) { cout << mx[rt] << " "; return ; }
        if (tag[rt]) pushdown(rt);
        int mid = (l + r) >> ;
        pr(lson); pr(rson);
    }
}T;
struct LCT{
    int fa[N], ch[N][];
    inline bool isroot(int x) { return ch[fa[x]][] != x && ch[fa[x]][] != x; }
    inline int son(int x) { return ch[fa[x]][] == x; }
    inline void rotate(int x) {
        int y = fa[x], z = fa[y], c = son(y), b = son(x), a = ch[x][!b];
        if (!isroot(y)) ch[z][c] = x; fa[x] = z;
        ch[x][!b] = y; fa[y] = x;
        ch[y][b] = a; if (a) fa[a] = y;
    }
    void splay(int x) {
        while (!isroot(x)) {
            int y = fa[x];
            if (isroot(y)) rotate(x);
            else {
                if (son(x) == son(y)) rotate(y), rotate(x);
                else rotate(x), rotate(x);
            }
        }
    }
    int find(int x) {
        while (ch[x][]) x = ch[x][];
        return x;
    }
    void access(int x) {
        for (int last = , t; x; last = x, x = fa[x]) {
            splay(x);
            if (ch[x][]) t = find(ch[x][]), T.update(Root, pos[t], pos[t] + siz[t] - , ); // 这里找到原树上的位置
            ch[x][] = last;
            if (ch[x][]) t = find(ch[x][]), T.update(Root, pos[t], pos[t] + siz[t] - , -);
        }
    }
}lct;
int main() {
    n = read(), m = read();
    for (int i = ; i < n; ++i) {
        int u = read(), v = read();
        add_edge(u, v);
    }
    dfs();
    for (int j = ; j <= Log; ++j)
        for (int i = ; i <= n; ++i) f[i][j] = f[f[i][j - ]][j - ];
    for (int i = ; i <= n; ++i) {
        T.update(Root, pos[i], pos[i], deth[i]);
        lct.fa[i] = f[i][];
    }
    while (m --) {
        int opt = read(), x = read();
        if (opt == ) lct.access(x);
        else if (opt == ) {
            int y = read(), z = LCA(x, y);
            printf("%d\n", T.query(Root, pos[x], pos[x]) + T.query(Root, pos[y], pos[y]) - T.query(Root, pos[z], pos[z]) *  + );
        }
        else {
            printf("%d\n", T.query(Root, pos[x], pos[x] + siz[x] - ));
        }
    }
    return ;
}