[SDOI2017]树点涂色

Description:

Bob有一棵$n$个点的有根树，其中1号点是根节点。Bob在每个点上涂了颜色，并且每个点上的颜色不同。

定义一条路径的权值是：这条路径上的点（包括起点和终点）共有多少种不同的颜色。

Bob可能会进行这几种操作：

$1$ $x$

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

$2$ $x$ $y$

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

$3$ $x$

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

Bob一共会进行$m$次操作

Hint:

$n,m\le 10^5$

solution:

首先我们需要维护每个点到根的权值

2 操作可以直接 $dis_u+dis_v-2*dis_{LCA}+1$

3 操作用线段树维护子树最值

但直接做的话每次修改会把一条路径上的所有节点的子树都改一遍

单次 $nlogn$ 复杂度爆炸

考虑其实一条路径上是若干段连续的颜色相等的区间

如果能维护这个东西复杂度就可以变成 $O(Color*logn) \approx O(log^2n)$

因为每种颜色都是一条链想到用 $LCT$ 的每颗$splay$ 维护一种颜色

这样我们修改时就方便得多

每次对一个点 $access$

对于父亲节点之前的儿子的子树权值整体 $+1$

对于当前节点子树权值整体 $-1$

就可以了复杂度 $O(nlog^2n)$

#include <map>

#include <set>

#include <stack>

#include <cmath>

#include <queue>

#include <cstdio>

#include <cstring>

#include <cstdlib>

#include <iostream>

#include <algorithm>

#define ls p<<1

#define rs p<<1|1

using namespace std;

typedef long long ll;

const int mxn=1e5+5;

int n,m,cnt,hd[mxn],fa[mxn],ch[mxn][2];

struct ed {

    int to,nxt;

}t[mxn<<1];

inline void add(int u,int v) {

    t[++cnt]=(ed) {v,hd[u]}; hd[u]=cnt;

}

inline int read() {

    char c=getchar(); int x=0,f=1;

    while(c>'9'||c<'0') {if(c=='-') f=-1;c=getchar();}

    while(c<='9'&&c>='0') {x=(x<<3)+(x<<1)+(c&15);c=getchar();}

    return x*f;

}

inline void chkmax(int &x,int y) {if(x<y) x=y;}

inline void chkmin(int &x,int y) {if(x>y) x=y;}

int tot,f[mxn],sz[mxn],rk[mxn],top[mxn],son[mxn],dep[mxn],dfn[mxn];

int tr[mxn<<2],tag[mxn<<2];

namespace Seg {

    void push_up(int p) {

        tr[p]=max(tr[ls],tr[rs]);

    }

    void push_down(int p) {

        if(tag[p]) {

            tag[ls]+=tag[p];

            tag[rs]+=tag[p];

            tr[ls]+=tag[p];

            tr[rs]+=tag[p];

            tag[p]=0;

        }

    }

    void dfs1(int u,int fa) {

        dep[u]=dep[fa]+1; f[u]=fa; sz[u]=1;

        for(int i=hd[u];i;i=t[i].nxt) {

            int v=t[i].to;

            if(v==fa) continue ;

            dfs1(v,u); sz[u]+=sz[v];

            if(sz[son[u]]<sz[v]) son[u]=v;

        }

    }

    void dfs2(int u,int tp) {

        dfn[u]=++tot; rk[tot]=u; top[u]=tp;

        if(son[u]) dfs2(son[u],tp),fa[son[u]]=u;

        for(int i=hd[u];i;i=t[i].nxt) {

            int v=t[i].to;

            if(v==f[u]||v==son[u]) continue ;

            dfs2(v,v); fa[v]=f[v];

        }

    }

    void build(int l,int r,int p) {

        if(l==r) {

            tr[p]=dep[rk[l]];

            return ;

        }

        int mid=(l+r)>>1;

        build(l,mid,ls);

        build(mid+1,r,rs);

        push_up(p);

    }

    int LCA(int x,int y) {

        while(top[x]!=top[y]) {

            if(dep[top[x]]<dep[top[y]]) swap(x,y);

            x=f[top[x]];

        }

        return dep[x]<dep[y]?x:y;

    }

    void update(int l,int r,int ql,int qr,int val,int p) {

        if(ql<=l&&r<=qr) {

            tr[p]+=val;

            tag[p]+=val;

            return ;

        }

        int mid=(l+r)>>1; push_down(p);

        if(ql<=mid) update(l,mid,ql,qr,val,ls);

        if(qr>mid) update(mid+1,r,ql,qr,val,rs);

        push_up(p);

    }

    int query(int l,int r,int ql,int qr,int p) {

        if(ql<=l&&r<=qr) return tr[p];

        int mid=(l+r)>>1; push_down(p); int res=0;

        if(ql<=mid) chkmax(res,query(l,mid,ql,qr,ls));

        if(qr>mid) chkmax(res,query(mid+1,r,ql,qr,rs));

        push_up(p); return res;

    }

    int ask(int x) {return query(1,n,dfn[x],dfn[x],1);}

}

using namespace Seg;

namespace lct {

    int isnotrt(int x) {

        return ch[fa[x]][0]==x||ch[fa[x]][1]==x;

    }

    void rotate(int x) {

        int y=fa[x],z=fa[y],tp=ch[y][1]==x;

        if(isnotrt(y)) ch[z][ch[z][1]==y]=x; fa[x]=z;

        ch[y][tp]=ch[x][tp^1]; fa[ch[x][tp^1]]=y;

        ch[x][tp^1]=y; fa[y]=x;

    }

    void splay(int x) {

        while(isnotrt(x)) {

            int y=fa[x],z=fa[y];

            if(isnotrt(y))

                (ch[y][1]==x)^(ch[z][1]==y)?rotate(x):rotate(y);

            rotate(x);

        }

    }

    void access(int x) {

        for(int y=0;x;x=fa[y=x]) {

            splay(x);

            if(ch[x][1]) { //这里是本题重点

                int pos=ch[x][1]; while(ch[pos][0]) pos=ch[pos][0];

                update(1,n,dfn[pos],dfn[pos]+sz[pos]-1,1,1);

            }

            ch[x][1]=y;

            if(ch[x][1]) {

                int pos=ch[x][1]; while(ch[pos][0]) pos=ch[pos][0];

                update(1,n,dfn[pos],dfn[pos]+sz[pos]-1,-1,1);

            }

        }

    }

}

using namespace lct;

int main()

{

    n=read(); m=read(); int opt,x,y,u,v;

    for(int i=1;i<n;++i) {

        u=read(); v=read();

        add(u,v); add(v,u);

    }

    dfs1(1,0); dfs2(1,1); build(1,n,1);

    for(int i=1;i<=m;++i) {

        opt=read();

        if(opt==1) x=read(),access(x);

        else if(opt==2) {

            x=read(); y=read(); int lca=LCA(x,y);

            printf("%d\n",ask(x)+ask(y)-2*ask(lca)+1);

        }

        else x=read(),printf("%d\n",query(1,n,dfn[x],dfn[x]+sz[x]-1,1));

    }

    return 0;

}