洛谷P2486 lct做法

最新推荐文章于 2025-07-04 09:22:55 发布

stdforces

最新推荐文章于 2025-07-04 09:22:55 发布

阅读量351

点赞数

CC 4.0 BY-SA版权

文章标签：算法 c++ 图论

本文链接：https://blog.youkuaiyun.com/stdforces/article/details/126699872

这篇博客介绍了一种利用LCT（Link Cut Tree）数据结构解决无根树上路径染色和查询颜色段数量的问题。LCT允许动态地增删边并维护树上路径信息。文章详细解释了LCT的内部操作，如旋转、反转、颜色更新等，并展示了如何在push_up过程中维护路径上的颜色段计数。此外，还给出了实现这些操作的C++代码片段，包括处理查询和修改操作的split、link、splay等函数。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题意：

给出一颗 $n$ 个结点的无根树，处理 $m$ 个操作，每个操作只会是如下两种之一：

（1）将结点 $a$ 到 $b$ 的路径上的所有点染成颜色 $k$

（2）询问结点 $a$ 到结点 $b$ 的简单路径的颜色段数量

LCT方法：

$L CT$ 是用来维护动态增删边和树上路径的数据结构

对于每个 $s pl a y$ ，维护的是一条链，节点 $x$ 在原树连接的是他在 $s pl a y$ 的前驱，不是 $s pl a y$ 的儿子， $x$ 的左子树是他之前的链，右子树是之后的链

对于路径 $(x, y)$ ，先 $s pl i t (x, y)$ ；

我们先考虑查询， $s u m$ 保存当前 $s pl a y$ 的“连接处”的个数，即相邻颜色不一样的节点对数，答案即 $t ree [y] . s u m + 1$ ，那么问题就到了如何在 $push\_up$ 中维护这个值，显然，对节点 $x$ ， $t ree [x] . s u m = t ree [so n [0]] . s u m + t ree [so n [1]] . s u m + x$ 节点对他前后两段形成的“连接处个数”，一种方法是找前驱，即用传统 $s pl a y$ 的方法，但在 $L CT$ 内由于 $p re ()$ 会调用 $s pl a y ()$ ， $s pl a y ()$ 会调用$push_up()
$，$ push_up $会调用$ pre() $，循环递归，会出现错误。另一种方法是新增成员，来保存当前$ splay $子树的最左端点和最右端点，这样贡献即$ tree[x].color!=tree[tree[x].son[i]].colorr[i] $，此时$ reverse() $也需要反转$ tree[x].colorr[i]$

修改操作只需 $s pl i t (x, y)$ 之后在 $y$ 处下放标记即可了

#include<bits/stdc++.h>
#define ll long long
using namespace std;

int n,q;

struct LCT
{
    struct node
    {
        int color,tag,sum,son[2],fa,lazy,colorr[2];
    };
    stack<int>s;
    vector<node>tree;
    LCT():tree(200005){}
    inline bool isroot(int x)
    {
        return tree[tree[x].fa].son[0]!=x&&tree[tree[x].fa].son[1]!=x;
    }
    inline int getson(int x,int y)
    {
        return x==tree[y].son[1];
    }
    inline void push_up(int x)
    {
        tree[x].sum=0;
		for(int i=0;i<=1;i++)
		{
			if(tree[x].son[i])
			{
				tree[x].sum+=tree[tree[x].son[i]].sum+(tree[x].color!=tree[tree[x].son[i]].colorr[!i]);
				tree[x].colorr[i]=tree[tree[x].son[i]].colorr[i];
			}
			else tree[x].colorr[i]=tree[x].color;
		}
    }
    inline void rotate(int x)
    {
        int y=tree[x].fa,z=tree[y].fa;
        int k1=getson(x,y),k2=getson(y,z);
        tree[x].fa=z;
        if(!isroot(y)) tree[z].son[k2]=x;
        tree[y].son[k1]=tree[x].son[!k1];
        if(tree[x].son[!k1]) tree[tree[x].son[!k1]].fa=y;
        tree[x].son[!k1]=y;
        tree[y].fa=x;
        push_up(y); push_up(x);
    }
    inline void reverse(int x)
    {
        swap(tree[x].son[0],tree[x].son[1]);
		swap(tree[x].colorr[0],tree[x].colorr[1]);
        tree[x].tag^=1;
    }
    inline void ccolor(int x,int k)
    {
        tree[x].lazy=k;
        tree[x].color=k;
        tree[x].sum=0;
		tree[x].colorr[0]=tree[x].colorr[1]=k;
    }
    void push_down(int x)
    {
        if(tree[x].tag)
        {
            for(int i=0;i<=1;i++)
                if(tree[x].son[i]) reverse(tree[x].son[i]);
            tree[x].tag=0;
        }
        if(tree[x].lazy)
        {
            for(int i=0;i<=1;i++)
                if(tree[x].son[i]) ccolor(tree[x].son[i],tree[x].lazy);
            tree[x].lazy=0;
        }
    }
    void splay(int x)
    {
        int now=x;
        s.push(now);
        while(!isroot(now))
        {
            s.push(tree[now].fa);
            now=tree[now].fa;
        }
        while(!s.empty())
        {
            push_down(s.top());
            s.pop();
        }
        while(!isroot(x))
        {
            int y=tree[x].fa,z=tree[y].fa;
            int k1=getson(x,y),k2=getson(y,z);
            if(!isroot(y))
            {
                if(k1==k2) rotate(y);
                else rotate(x);
            }
            rotate(x);
        }
    }
    inline void access(int x)//打通root->x的splay
    {
        int last=0;
        while(x)
        {
            splay(x);
            tree[x].son[1]=last;
            push_up(last=x);
            x=tree[x].fa;
        }
    }
    inline void makeroot(int x)
    {
        access(x);
        splay(x);
        reverse(x);
    }
    inline int findroot(int x)
    {
        access(x);
        splay(x);
        while(tree[x].son[0])
        {
            push_down(x);
            x=tree[x].son[0];
        }
        splay(x);
        return x;
    }
    inline void split(int x,int y)
    {
        makeroot(x);
        access(y);
        splay(y);
    }
    inline void link(int x,int y)
    {
        makeroot(x);
        tree[x].fa=y;
    }
}lct;

int main()
{
    cin>>n>>q;
    int nn=n;
    for(int i=1;i<=n;i++) scanf("%d",&lct.tree[i].color);
    for(int i=1;i<n;i++)
    {
        int u,v; scanf("%d%d",&u,&v);
        lct.link(u,v);
    }
    while(q--)
    {
        // lct.dfs();
        char s[5]; scanf("%s",s+1);
        if(s[1]=='Q')
        {
            int x,y; scanf("%d%d",&x,&y);
            lct.split(x,y);
            printf("%d\n",lct.tree[y].sum+1);
        }
        else
        {
            int x,y,k; scanf("%d%d%d",&x,&y,&k);
            lct.split(x,y); lct.ccolor(y,k);
        }
    }
    return 0;
}