【SDOI2017】树点染色【线段树+LCT】

本来只是想练练LCT，没想到是个线段树

对于操作1：诶新的颜色？这不是access吗？

也就是说，我们用一棵splay来表示一种颜色

操作2直接在LCT上乱搞……

不对啊，操作3要查子树

诶好像是静态的

那可以考虑线段树维护dfs序

现在要考虑怎么维护权值

我们发现开始的时候权值就是节点的深度

而在且只在access的时候会改变权值

试试魔改access？

原来：

for (int y=0;x;y=x,x=fa[x])
{
    splay(x);
    ch[x][1]=y;
    update(x);
}

那么主要就是\(ch[x][1]=y\)

实际上这句话包含两个操作：清除\(ch[x][1]\),把\(y\)接到\(x\)的右儿子

清除\(ch[x][1]\),相当于把原来的重边断开

我们只考虑当前这个点改了之后的影响

注意既然他们是重边连起来的，他们原来一定是同色的

而改了之后他们就不同了，所以y的子树权值都会增加1

并且他也不会和这条到根路径上任何一个出现过的颜色相同

同样，把\(y\)接到\(x\)的右儿子，意味着x和y同色了，而原来是不同的，所以y的子树权值都会减少1

线段树维护一下就好

操作2直接单点查询，类似树上前缀和就可以了

于是乎，LCT40多行……

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cctype>
#define MAXN 1000005
#define MAXM 2000005
using namespace std;
inline int read()
{
    int ans=0;
    char c=getchar();
    while (!isdigit(c)) c=getchar();
    while (isdigit(c)) ans=(ans<<3)+(ans<<1)+(c^48),c=getchar();
    return ans;
}
struct edge
{
    int u,v;
}e[MAXM];
int head[MAXN],nxt[MAXM],cnt;
void addnode(int u,int v)
{
    e[++cnt]=(edge){u,v};
    nxt[cnt]=head[u];
    head[u]=cnt;
}
int dep[MAXN],fa[MAXN],up[MAXN][20];
int dfn[MAXN],pos[MAXN],tim,end[MAXN];
void dfs(int u)
{
    dfn[u]=++tim;
    pos[tim]=u;
    for (int i=1;i<20;i++)
        up[u][i]=up[up[u][i-1]][i-1];
    for (int i=head[u];i;i=nxt[i])
        if (!dep[e[i].v])
        {
            dep[e[i].v]=dep[u]+1;
            up[e[i].v][0]=u;
            fa[e[i].v]=u;
            dfs(e[i].v);
        }
    end[u]=tim;
}
int lca(int x,int y)
{
    if (dep[x]<dep[y]) swap(x,y);
    int t=dep[x]-dep[y];
    for (int i=0;(1<<i)<=t;i++)
        if (t&(1<<i))
            x=up[x][i];
    if (x==y) return x;
    for (int i=19;i>=0;i--)
        if (up[x][i]!=up[y][i])
            x=up[x][i],y=up[y][i];
    return up[x][0];
}
namespace SGT
{
    #define lc p<<1
    #define rc p<<1|1
    struct SegmentTree
    {
        int l,r;
        int lazy;
        int mx;
    }t[MAXN<<2];
    void pushup(int p){t[p].mx=max(t[lc].mx,t[rc].mx);} 
    void pushlazy(int p,int v){t[p].mx+=v,t[p].lazy+=v;}
    void pushdown(int p) 
    {
        if (t[p].lazy)
        {
            pushlazy(lc,t[p].lazy);
            pushlazy(rc,t[p].lazy);
            t[p].lazy=0;
        }
    }
    void build(int p,int l,int r)
    {
        t[p].l=l,t[p].r=r;
        if (l==r){t[p].mx=dep[pos[l]];return;}
        int mid=(l+r)>>1;
        build(lc,l,mid),build(rc,mid+1,r);
        pushup(p);
    }
    void modify(int p,int l,int r,int v)
    {
        if (l<=t[p].l&&t[p].r<=r) return pushlazy(p,v);
        if (r<t[p].l||t[p].r<l) return;
        pushdown(p);
        if (l<=t[lc].r) modify(lc,l,r,v);
        if (t[rc].l<=r) modify(rc,l,r,v);
        pushup(p);
    }
    int querymax(int p,int l,int r)
    {
        pushdown(p);
        if (l<=t[p].l&&t[p].r<=r) return t[p].mx;
        if (r<t[p].l||t[p].r<l) return 0;
        int ans=0;
        if (l<=t[lc].r) ans=max(ans,querymax(lc,l,r));
        if (t[rc].l<=r) ans=max(ans,querymax(rc,l,r));
        return ans;
    }
    int query(int p,int k)
    {
        pushdown(p);
        if (t[p].l==t[p].r) return t[p].mx;
        if (k<=t[lc].r) return query(lc,k);
        else return query(rc,k);
    }
}
using namespace SGT;
namespace Splay
{
    int ch[MAXN][2];
    bool isroot(int x){return ch[fa[x]][0]!=x&&ch[fa[x]][1]!=x;}
    int get(int x){return ch[fa[x]][1]==x;}
    void rotate(int x)
    {
        int y=fa[x],z=fa[y];
        int l=get(x),r=l^1;
        int w=ch[x][r];
        if (!isroot(y)) ch[z][get(y)]=x;
        ch[x][r]=y,ch[y][l]=w;
        if (w) fa[w]=y;
        fa[y]=x,fa[x]=z;
    }
    void splay(int x)
    {
        while (!isroot(x))
        {
            int y=fa[x];
            if (!isroot(y))
            {
                if (get(x)==get(y)) rotate(y);
                else rotate(x);
            }
            rotate(x);
        }
    }
}
using namespace Splay;
namespace LCT
{
    int findroot(int x){while (ch[x][0]) x=ch[x][0];return x;}
    void access(int x)
    {
        int w;
        for (int y=0;x;y=x,x=fa[x])
        {
            splay(x);
            if (ch[x][1]){w=findroot(ch[x][1]),modify(1,dfn[w],end[w],1);}
            if (ch[x][1]=y){w=findroot(y),modify(1,dfn[w],end[w],-1);}
        }
    }
}
using namespace LCT;
int main()
{
    int n,m;
    n=read(),m=read();
    for (int i=1;i<n;i++)
    {
        int u,v;
        u=read(),v=read();
        addnode(u,v),addnode(v,u);
    }
    dep[1]=1;
    dfs(1);
    build(1,1,n);
    while (m--)
    {
        int op,x,y,l;
        op=read(),x=read();
        int ans;
        switch(op)
        {
            case 1:access(x);break;
            case 2:
                y=read();
                l=lca(x,y);
                ans=query(1,dfn[x]);
                ans+=query(1,dfn[y]);
                ans-=(query(1,dfn[l])<<1);
                printf("%d\n",ans+1);
                break;
            case 3:
                printf("%d\n",querymax(1,dfn[x],end[x]));
        }
    }
    return 0;
}

转载于:https://www.cnblogs.com/lstoi/p/9871920.html