[SDOI2017]树点涂色

题意

有操作：

• 1 $x$

把点 $x$ 到根节点的路径上所有的点染上一种没有用过的新颜色。

• 2 $x$ $y$

求 $x$ 到 $y$ 的路径的权值。

• 3 $x$

在以 $x$ 为根的子树中选择一个点，使得这个点到根节点的路径权值最大，求最大权值。

题解

因为观察到一个颜色一定是一条向根节点的链，也就是说一条链代表了一个信息，那么就可以用 $LCT$ 中的一个 $Splay$ 去维护一条链（颜色）

那么一个节点的“权值”即为它到根节点经过的轻边个数，求出单点“权值”后，直接用差分即可解决操作 $2$

用树剖可以解决，但是这样的话连 $LCT$ 都不用了，同理，想到 $dfs$ 序，在 $Access$ 操作的时候删掉一条轻边并且增加一条轻边，答案有修改的只有该轻边端点包含的子树，那么直接线段树修改就好了

代码

#include <iostream>
#include <cstdio>
#include <cstring>

#define lson root << 1
#define rson root << 1 | 1

using namespace std;

const int MAXN = 1e05 + 10;
const int MAXM = 1e05 + 10;

struct LinkedForwardStar {
    int to;

    int next;
} ;

LinkedForwardStar Link[MAXM << 1];
int Head[MAXN]= {0};
int size = 0;

void Insert (int u, int v) {
    Link[++ size].to = v;
    Link[size].next = Head[u];

    Head[u] = size;
}

const int Root = 1;

int Deep[MAXN];
int Size[MAXN]= {0};
int Dfn[MAXN], Rank[MAXN];
int dfsord = 0;

int Maxv[MAXN << 2]= {0};
int lazy[MAXN << 2]= {0};
void pushdown (int root) {
    if (lazy[root]) {
        Maxv[lson] += lazy[root];
        Maxv[rson] += lazy[root];
        lazy[lson] += lazy[root];
        lazy[rson] += lazy[root];
        lazy[root] = 0;
    }
}
void Build (int root, int left, int right) {
    if (left == right) {
        Maxv[root] = Deep[Rank[left]];
        return ;
    }
    int mid = (left + right) >> 1;
    Build (lson, left, mid);
    Build (rson, mid + 1, right);
    Maxv[root] = max (Maxv[lson], Maxv[rson]);
}
void Modify (int root, int left, int right, int L, int R, int delta) {
    if (L <= left && right <= R) {
        Maxv[root] += delta;
        lazy[root] += delta;
        return ;
    }
    pushdown (root);
    int mid = (left + right) >> 1;
    if (L <= mid)
        Modify (lson, left, mid, L, R, delta);
    if (R >  mid)
        Modify (rson, mid + 1, right, L, R, delta);
    Maxv[root] = max (Maxv[lson], Maxv[rson]);
}
int Query (int root, int left, int right, int L, int R) {
    if (L <= left && right <= R)
        return Maxv[root];
    pushdown (root);
    int mid = (left + right) >> 1;
    int maxv = 0;
    if (L <= mid)
        maxv = max (maxv, Query (lson, left, mid, L, R));
    if (R > mid)
        maxv = max (maxv, Query (rson, mid + 1, right, L, R));
    return maxv;
}

int N, M;

int father[MAXN]= {0};
int son[MAXN][2]= {0};
int isroot (int p) {
    return son[father[p]][0] != p && son[father[p]][1] != p;
}
int sonbel (int p) {
    return son[father[p]][1] == p;
}
void rotate (int p) {
    int fa = father[p], anc = father[fa];
    int s = sonbel (p);
    son[fa][s] = son[p][s ^ 1];
    if (son[fa][s])
        father[son[fa][s]] = fa;
    if (! isroot (fa))
        son[anc][sonbel (fa)] = p;
    father[p] = anc;
    son[p][s ^ 1] = fa, father[fa] = p;
}
void splay (int p) {
    for (int fa = father[p]; ! isroot (p); rotate (p), fa = father[p])
        if (! isroot (fa))
            sonbel (p) == sonbel (fa) ? rotate (fa) : rotate (p);
}
int findroot (int p) {
    while (son[p][0])
        p = son[p][0];
    return p;
}
void Access (int p) {
    for (int tp = 0; p; tp = p, p = father[p]) {
        splay (p);
        if (son[p][1]) {
            int rt = findroot (son[p][1]);
            Modify (Root, 1, N, Dfn[rt], Dfn[rt] + Size[rt] - 1, 1);
        }
        son[p][1] = tp;
        if (son[p][1]) {
            int rt = findroot (son[p][1]);
            Modify (Root, 1, N, Dfn[rt], Dfn[rt] + Size[rt] - 1, - 1);
        }
    }
}

int ances[MAXN][20];
void DFS (int root, int fa) {
    Dfn[root] = ++ dfsord, Rank[dfsord] = root;
    ances[root][0] = father[root] = fa;
    for (int j = 1; j <= 18; j ++) {
        if (! ances[root][j - 1])
            break;
        ances[root][j] = ances[ances[root][j - 1]][j - 1];
    }
    Size[root] = 1;
    for (int i = Head[root]; i; i = Link[i].next) {
        int v = Link[i].to;
        if (v == fa)
            continue;
        Deep[v] = Deep[root] + 1;
        DFS (v, root);
        Size[root] += Size[v];
    }
}

int LCA (int x, int y) {
    if (Deep[x] < Deep[y])
        swap (x, y);
    int fx = x, fy = y;
    for (int j = 18; j >= 0; j --)
        if (Deep[ances[fx][j]] >= Deep[fy])
            fx = ances[fx][j];
    if (fx == fy)
        return fy;
    for (int j = 18; j >= 0; j --)
        if (ances[fx][j] != ances[fy][j]) {
            fx = ances[fx][j];
            fy = ances[fy][j];
        }
    return ances[fx][0];
}

int getnum () {
    int num = 0;
    char ch = getchar ();

    while (! isdigit (ch))
        ch = getchar ();
    while (isdigit (ch))
        num = (num << 3) + (num << 1) + ch - '0', ch = getchar ();

    return num;
}

int main () {
    N = getnum (), M = getnum ();
    for (int i = 1; i < N; i ++) {
        int u = getnum (), v = getnum ();
        Insert (u, v), Insert (v, u);
    }
    Deep[Root] = 1, DFS (Root, 0);
    Build (Root, 1, N);
    for (int i = 1; i <= M; i ++) {
        int opt = getnum ();
        if (opt == 1) {
            int p = getnum ();
            Access (p);
        }
        else if (opt == 2) {
            int x = getnum (), y = getnum ();
            int lca = LCA (x, y);
            int qx = Query (Root, 1, N, Dfn[x], Dfn[x]);
            int qy = Query (Root, 1, N, Dfn[y], Dfn[y]);
            int qlca = Query (Root, 1, N, Dfn[lca], Dfn[lca]);
            int ans = qx + qy - (qlca << 1) + 1;
            printf ("%d
", ans);
        }
        else if (opt == 3) {
            int p = getnum ();
            int ans = Query (Root, 1, N, Dfn[p], Dfn[p] + Size[p] - 1);
            printf ("%d
", ans);
        }
    }

    return 0;
}

/*
5 6
1 2
2 3
3 4
3 5
2 4 5
3 3
1 4
2 4 5
1 5
2 4 5
*/