BZOJ 4817 [SDOI2017]树点涂色 (LCT+线段树维护dfs序)

题目大意：略

涂色方式明显符合$LCT$里$access$操作的性质，相同颜色的节点在一条深度递增的链上

用$LCT$维护一个树上集合就好

因为它维护了树上集合，所以它别的啥都干不了了

发现树是静态的，可以用$dfs$序搞搞

把问题当成树上节点涂色会很麻烦

但只有相邻的不同颜色节点才会对答案产生影响

所以我们把涂色当成一种连边/断边操作

这样，问题就容易解决得多了

维护一个数组$f_{x}$表示$x$节点到根的路径上一共有$f_{x}$种颜色，$f_{x}-1$条断边

显然它的初始值就是节点x的深度

第一个操作，把这个位置到根打通

每断一条边，子树每个节点答案$+1$，连一条边，答案$-1$

在$access$操作中进行讨论即可

第二个操作，求链上不同颜色数量，即一个链的断边数量$-1$

显然，答案是$(f_{x}-1)+(f_{y}-1)-2*(f_{lca(x,y)}-1)+1=f_{x}+f_{y}-2*f_{lca(x,y)}+1$

即断边总数$+1$

不要把它当成节点的颜色去想

第三个操作，求子树内$f_{x}$最大值

以上操作皆可用$dfs$序+线段树实现！

随时保持清醒头脑，千万不要把这个$LCT$当成真正的$LCT$，它只是一个维护链集合的媒介！

尤其是断边/连边，进行区间修改操作时，需要找出开头/后继节点，而不是当前splay的根节点

#include <queue>
#include <vector>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define N1 101000
#define S1 (N1<<1)
#define T1 (N1<<2)
#define ll long long
#define uint unsigned int
#define rint register int 
#define ull unsigned long long
#define dd double
#define il inline 
#define inf 1000000000
using namespace std;

int gint()
{
    int ret=0,fh=1;char c=getchar();
    while(c<'0'||c>'9'){if(c=='-')fh=-1;c=getchar();}
    while(c>='0'&&c<='9'){ret=ret*10+c-'0';c=getchar();}
    return ret*fh;
}
int n,m,T;
struct Edge{
int to[N1*2],nxt[N1*2],head[N1],cte;
void ae(int u,int v)
{cte++;to[cte]=v,nxt[cte]=head[u],head[u]=cte;}
}E;

struct SEG{
int ma[N1<<2],tag[N1<<2];
void pushup(int rt){ma[rt]=max(ma[rt<<1],ma[rt<<1|1]);}
void pushdown(int rt)
{
    if(!tag[rt]) return;
    ma[rt<<1]+=tag[rt]; ma[rt<<1|1]+=tag[rt];
    tag[rt<<1]+=tag[rt]; tag[rt<<1|1]+=tag[rt];
    tag[rt]=0;
}
void build(int *a,int *id,int l,int r,int rt)
{
    if(l==r) {ma[rt]=a[id[l]];return;}
    int mid=(l+r)>>1;
    build(a,id,l,mid,rt<<1);
    build(a,id,mid+1,r,rt<<1|1);
    pushup(rt);
}
void update(int L,int R,int l,int r,int rt,int w)
{
    if(!L||!R||L>R) return;
    if(L<=l&&r<=R) {ma[rt]+=w,tag[rt]+=w;return;}
    int mid=(l+r)>>1; pushdown(rt);
    if(L<=mid) update(L,R,l,mid,rt<<1,w);
    if(R>mid) update(L,R,mid+1,r,rt<<1|1,w);
    pushup(rt);
}
int query(int L,int R,int l,int r,int rt)
{
    if(L<=l&&r<=R) return ma[rt];
    int mid=(l+r)>>1,ans=0; pushdown(rt);
    if(L<=mid) ans=max(ans,query(L,R,l,mid,rt<<1));
    if(R>mid) ans=max(ans,query(L,R,mid+1,r,rt<<1|1));
    return ans;
}
}s;

namespace lct{
int ch[N1][2],fa[N1];
int idf(int x){return ch[fa[x]][0]==x?0:1;}
int isroot(int x){return (ch[fa[x]][0]==x||ch[fa[x]][1]==x)?0:1;}
//int stk[N1],tp;
void rot(int x)
{
    int y=fa[x],ff=fa[y],px=idf(x),py=idf(y);
    if(!isroot(y)) ch[ff][py]=x; fa[x]=ff; 
    fa[ch[x][px^1]]=y,ch[y][px]=ch[x][px^1];
    ch[x][px^1]=y,fa[y]=x;
    //pushup(y),pushup(x);
}
void splay(int x)
{
    int y=x; /*stk[++tp]=x;
    while(!isroot(y)){stk[++tp]=fa[y],y=fa[y];}
    while(tp){pushdown(stk[tp--]);}*/
    while(!isroot(x))
    {
        y=fa[x];
        if(isroot(y)) rot(x);
        else if(idf(y)==idf(x)) rot(y),rot(x);
        else rot(x),rot(x);
    }
}
int First(int x){while(ch[x][0]) x=ch[x][0];return x;}
int upper(int x){x=ch[x][1];while(ch[x][0]) x=ch[x][0];return x;}
void access(int x,int *st,int *ed)
{
    for(int y=0,z;x;)
    {
        splay(x);
        z=upper(x);
        if(z) s.update(st[z],ed[z],1,n,1,1);
        z=First(y);
        s.update(st[z],ed[z],1,n,1,-1);
        ch[x][1]=y; y=x; x=fa[x]; 
    }
}
void init(int *ff){
    for(int i=2;i<=n;i++) fa[i]=ff[i];
}
};

int fa[N1],son[N1],sz[N1],tp[N1],dep[N1];
int st[N1],ed[N1],id[N1],tot;
void dfs1(int u,int ff)
{
    for(int j=E.head[u];j;j=E.nxt[j])
    {
        int v=E.to[j];
        if(v==ff) continue;
        dep[v]=dep[u]+1; dfs1(v,u); fa[v]=u;
        sz[u]+=sz[v]; son[u]=sz[v]>sz[son[u]]?v:son[u];
    }
    sz[u]++;
}
void dfs2(int u)
{
    st[u]=ed[u]=++tot; id[tot]=u;
    if(son[u]) tp[son[u]]=tp[u], dfs2(son[u]), ed[u]=max(ed[u],ed[son[u]]);;
    for(int j=E.head[u];j;j=E.nxt[j])
    {
        int v=E.to[j];
        if(v==fa[u]||v==son[u]) continue;
        tp[v]=v; dfs2(v);
        ed[u]=max(ed[u],ed[v]);
    }
}
int lca(int x,int y)
{
    while(tp[x]!=tp[y])
    {
        if(dep[tp[x]]<dep[tp[y]]) swap(x,y);
        x=fa[tp[x]];
    }
    return dep[x]<dep[y]?x:y;
}
void mksame(int x)
{
    lct::access(x,st,ed);
}
int split(int x,int y)
{
    int sx,sy,sf,f=lca(x,y);
    sx=s.query(st[x],st[x],1,n,1);
    sy=s.query(st[y],st[y],1,n,1);
    sf=s.query(st[f],st[f],1,n,1);
    return sx+sy-2*sf+1;
}
int qmax(int x){return s.query(st[x],ed[x],1,n,1);}
void init()
{
    dep[1]=1; dfs1(1,-1);
    tp[1]=1; dfs2(1);
    lct::init(fa);
    s.build(dep,id,1,n,1);
}

int qf(int x){return s.query(st[x],st[x],1,n,1);}

int main()
{
    scanf("%d%d",&n,&m);
    int i,j,fl,x,y,cnt=0,de; 
    for(i=1;i<n;i++) x=gint(), y=gint(), E.ae(x,y), E.ae(y,x);
    init();
    for(j=1;j<=m;j++)
    {
        fl=gint();
        if(fl==1){
            x=gint();
            mksame(x);
        }else if(fl==2){
            x=gint(); y=gint();
            printf("%d
",split(x,y));
        }else{
            x=gint();
            printf("%d
",qmax(x));
        }
    }
    return 0;
}