BZOJ4817 [Sdoi2017]树点涂色 【LCT + 线段树】

题目

Bob有一棵n个点的有根树，其中1号点是根节点。Bob在每个点上涂了颜色，并且每个点上的颜色不同。定义一条路
径的权值是：这条路径上的点（包括起点和终点）共有多少种不同的颜色。Bob可能会进行这几种操作：
1 x:
把点x到根节点的路径上所有的点染上一种没有用过的新颜色。
2 x y:
求x到y的路径的权值。
3 x y:
在以x为根的子树中选择一个点，使得这个点到根节点的路径权值最大，求最大权值。
Bob一共会进行m次操作

输入格式

第一行两个数n,m。
接下来n-1行，每行两个数a,b，表示a与b之间有一条边。
接下来m行，表示操作，格式见题目描述
1<=n,m<=100000

输出格式

每当出现2,3操作，输出一行。
如果是2操作，输出一个数表示路径的权值
如果是3操作，输出一个数表示权值的最大值

输入样例

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

输出样例

3

4

2

2

题解

我们发现只有\(1\)操作改变了颜色，而且改变到根的路径上的点
我们很容易想到LCT的Access
由此可以发现，如果我们把整棵树看做LCT的话，那么在同一个splay中的点属于一种颜色
由此，一个节点到根的色数 = 轻链数 + 1

所以我们只需要维护每个节点到根的轻链数，记为\(f[i]\)
对于\(ans2\)：\(ans = f[u] + f[v] - 2 * f[lca] + 1\)
对于\(ans3\)：要求一个子树的最大值，我们建一棵线段树，然后利用dfs序就可以实现

如何维护\(f[i]\)？
考虑Access的时候，
我们每建立一条轻边，那么这条边往下所有点\(f[i] + 1\)
我们每建立一条重边，那么这条边往下所有点\(f[i] - 1\)

这样我们就做完了
一堆模板码着真爽

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#define LL long long int
#define Redge(u) for (int k = h[u],to; k; k = ed[k].nxt)
#define REP(i,n) for (int i = 1; i <= (n); i++)
#define BUG(s,n) for (int i = 1; i <= (n); i++) cout<<s[i]<<' '; puts("");
#define ls ch[u][0]
#define rs ch[u][1]
#define isrt(u) (!fa[u] || (ch[fa[u]][0] != u && ch[fa[u]][1] != u))
#define isr(u) (ch[fa[u]][1] == u)
using namespace std;
const int maxn = 100005,maxm = 200005,INF = 1000000000;
inline int read(){
    int out = 0,flag = 1; char c = getchar();
    while (c < 48 || c > 57){if (c == '-') flag = -1; c = getchar();}
    while (c >= 48 && c <= 57){out = (out << 3) + (out << 1) + c - 48; c = getchar();}
    return out * flag;
}
int h[maxn],ne = 2,n,m,H[maxn],dfn[maxn],siz[maxn],dep[maxn],pre[maxn][18],cnt;
struct EDGE{int to,nxt;}ed[maxm];
inline void build(int u,int v){
    ed[ne] = (EDGE){v,h[u]}; h[u] = ne++;
    ed[ne] = (EDGE){u,h[v]}; h[v] = ne++;
}
struct SegmentTree{
    int mx[4 * maxn],tag[4 * maxn];
    void pd(int u){
        if (tag[u]){
            mx[u << 1] += tag[u];
            tag[u << 1] += tag[u];
            mx[u << 1 | 1] += tag[u];
            tag[u << 1 | 1] += tag[u];
            tag[u] = 0;
        }
    }
    void upd(int u){mx[u] = max(mx[u << 1],mx[u << 1 | 1]);}
    void build(int u,int l,int r){
        if (l == r){mx[u] = dep[H[l]]; return;}
        int mid = l + r >> 1;
        build(u << 1,l,mid);
        build(u << 1 | 1,mid + 1,r);
        upd(u);
    }
    void add(int u,int l,int r,int L,int R,int v){
        if (l >= L && r <= R){mx[u] += v; tag[u] += v; return;}
        pd(u);
        int mid = l + r >> 1;
        if (mid >= L) add(u << 1,l,mid,L,R,v);
        if (mid < R) add(u << 1 | 1,mid + 1,r,L,R,v);
        upd(u);
    }
    int query(int u,int l,int r,int L,int R){
        if (l >= L && r <= R) return mx[u];
        pd(u);
        int mid = l + r >> 1;
        if (mid >= R) return query(u << 1,l,mid,L,R);
        if (mid < L) return query(u << 1 | 1,mid + 1,r,L,R);
        return max(query(u << 1,l,mid,L,R),query(u << 1 | 1,mid + 1,r,L,R));
    }
}Seg;
struct LCTree{
    int ch[maxn][2],fa[maxn],mn[maxn];
    void pup(int u){
        mn[u] = u;
        if (ls && dep[mn[ls]] < dep[mn[u]]) mn[u] = mn[ls];
        if (rs && dep[mn[rs]] < dep[mn[u]]) mn[u] = mn[rs];
    }
    void spin(int u){
        int s = isr(u),f = fa[u];
        fa[u] = fa[f]; if (!isrt(f)) ch[fa[f]][isr(f)] = u;
        ch[f][s] = ch[u][s ^ 1]; if (ch[u][s ^ 1]) fa[ch[u][s ^ 1]] = f;
        fa[f] = u; ch[u][s ^ 1] = f;
        pup(f); pup(u);
    }
    void splay(int u){
        for (; !isrt(u); spin(u))
            if (!isrt(fa[u])) spin((isr(u) ^ isr(fa[u])) ? u : fa[u]);
    }
    void Access(int u){
        for (int v = 0,t; u; u = fa[v = u]){
            splay(u);
            if (rs){
                t = mn[rs];
                Seg.add(1,1,n,dfn[t],dfn[t] + siz[t] - 1,1);
                rs = 0;
            }
            if (v){
                t = mn[v];
                Seg.add(1,1,n,dfn[t],dfn[t] + siz[t] - 1,-1);
                rs = v;
            }
        }
    }
}LCT;
void dfs(int u){
    dfn[u] = ++cnt; siz[u] = 1; H[cnt] = u;
    REP(i,17) pre[u][i] = pre[pre[u][i - 1]][i - 1];
    Redge(u) if ((to = ed[k].to) != pre[u][0]){
        dep[to] = dep[u] + 1;
        LCT.fa[to] = pre[to][0] = u;
        dfs(to);
        siz[u] += siz[to];
    }
}
int lca(int u,int v){
    if (dep[u] < dep[v]) swap(u,v);
    for (int i = 0,d = dep[u] - dep[v]; (1 << i) <= d; i++)
        if (d & (1 << i)) u = pre[u][i];
    if (u == v) return u;
    for (int i = 17; i >= 0; i--)
        if (pre[u][i] != pre[v][i]){
            u = pre[u][i];
            v = pre[v][i];
        }
    return pre[u][0];
}
void init(){
    n = read(); m = read();
    for (int i = 1; i < n; i++) build(read(),read());
    for (int i = 1; i <= n; i++) LCT.mn[i] = i;
    dfs(1);
    Seg.build(1,1,n);
}
void solve(){
    int opt,u,v,o,ans;
    while (m--){
        opt = read(); u = read();
        if (opt == 1) LCT.Access(u);
        if (opt == 2) {
            v = read();
            o = lca(u,v);
            ans = Seg.query(1,1,n,dfn[u],dfn[u]);
            ans += Seg.query(1,1,n,dfn[v],dfn[v]);
            ans -= Seg.query(1,1,n,dfn[o],dfn[o]) * 2;
            printf("%d\n",ans + 1);
        }
        if (opt == 3){
            ans = Seg.query(1,1,n,dfn[u],dfn[u] + siz[u] - 1);
            printf("%d\n",ans + 1);
        }
    }
}
int main(){
    init();
    solve();
    return 0;
}

转载于:https://www.cnblogs.com/Mychael/p/8797846.html