LCT学习笔记

最新推荐文章于 2022-07-19 18:29:07 发布
最新推荐文章于 2022-07-19 18:29:07 发布
阅读量338 收藏
点赞数
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Timsei/article/details/77387913
版权

LCT是一种比较神的数据结构，它能够支持对树的link,cut,换根和各种维护边权点权，链的信息的比较神的数据结构。其主要思想是利用splay维护每一条偏爱链，利用access操作，动态的变幻树的结构，以达到查询目的。

splay以深度为关键字。

splay要求支持：

int fa[N] , ch[N][2] , S[N] , a[N];
bool rev[N];

void pushup(int x) {
    S[x] = S[ch[x][0]] + S[ch[x][1]] + 1;
}

void pushdown(int x) {
    if(rev[x]) {
        rev[ch[x][0]] ^= 1;
        rev[ch[x][1]] ^= 1;
        swap(ch[x][0],ch[x][1]);
        rev[x] = 0;
    }
}

int dir(int x) {
    return (x == ch[fa[x]][1]);
}

bool isroot(int x) {
    return ((ch[fa[x]][0] != x) && (ch[fa[x]][1] != x));
}

void rotate(int x) {
    int F = fa[x] , GF = fa[F];
    int dir_x = dir(x);
    if(!isroot(F)) ch[GF][dir(F)] = x;
    fa[x] = GF; fa[F] = x;
    ch[F][dir_x] = ch[x][!dir_x];
    if(ch[x][!dir_x])fa[ch[x][!dir_x]] = F;
    ch[x][!dir_x] = F;
    pushup(F);pushup(x);
}

void splay(int x) {
    stack<int>F;
    while(!F.empty()) F.pop();
    F.push(x);
    //* * * warning* * *//
    for(int i = x;!isroot(i);i = fa[i]) F.push(fa[i]);
    while(!F.empty()) {
        int V = F.top(); F.pop();
        pushdown(V);
    }
    while(!isroot(x) && !isroot(fa[x])) {
        if(dir(fa[x]) == dir(x)) {
            rotate(fa[x]); rotate(x);
        }
        else rotate(x) , rotate(x);
    }
    if(!isroot(x)) rotate(x);
}

access(x)操作,可以把x到x这个联通块的根在splay上连接起来：
具体是从x一直往上跳先，把他旋到原联通块splay的根，把原来的右儿子赋给x到根路径上的下一个点，如果是x，那么就应该断开他的右儿子。
因为是splay，所以不用管左儿子（仔细思考）。

void access(int x) {
    int t = 0;
    while(x) {
        splay(x);
        ch[x][1] = t;
        pushup(x);
        t = x;
        x = fa[x];
    }
}

make_root操作，先access(x),之后把x，旋到根，将这条链上的所有点的splay树上的左右儿子交换——即深度倒序。
直观地理解一下：
x的儿子对于x的深度大小关系不变，链上其它点的子树对于其父亲深度关系不变，只有链上的点深度倒了一下，就打个交换标记即可。

void make_root(int x) {
    access(x); splay(x); rev[x] ^= 1;
}

link(x,y)直接x变根然后把y赋成他的父亲。

void link(int x,int y) {
    make_root(x); fa[x] = y;
}

cut 很直观。

void cut(int x ,int y) {
    make_root(x);access(y);
    splay(y);
    ch[y][0] = fa[x] = 0 ,pushup(y);
}

查询连通性：找联通快的根比较是否相同：

int find(int x) {
    access(x);
    splay(x);
    while(ch[x][0]) x = ch[x][0];
    return x;
}

例题1：
BZOJ2049cave

裸题判连通性。

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

const int N = 10005;

char ty[11];

int n , m  , x , y , fa[N] , ch[N][2];
bool rev[N];

inline bool isroot(int x) {
    return ((ch[fa[x]][0] != x) && (ch[fa[x]][1] != x));
}

inline int dir(int x) {
    return (ch[fa[x]][1] == x);
}

inline void pushdown(int x) {
    if(rev[x]) {
        rev[x] = 0;
        swap(ch[x][0] , ch[x][1]);
        rev[ch[x][0]] ^= 1;
        rev[ch[x][1]] ^= 1;
    }
}

inline void rotate(int x) {
    int F = fa[x] , dir_x = dir(x), GF = fa[F];
    if(!isroot(F)) {
        ch[GF][dir(F)] = x;
    }
    fa[F] = x; fa[x] = GF;
    ch[F][dir_x] = ch[x][!dir_x];
    if(ch[F][dir_x]) fa[ch[F][dir_x]] = F;
    ch[x][!dir_x] = F;
}

int st[N];

inline void splay(int x) {
    int top = 0;
    st[++top] = x;
    for(int i = x;!isroot(i);i = fa[i]) {
        st[++ top] = fa[i];
    }
    while(1) {
        pushdown(st[top]);
        top --;
        if(top ==0) break;
    }
    while(!isroot(x) && !isroot(fa[x])) {
        if(dir(x) == dir(fa[x])) {
            rotate(fa[x]);rotate(x);
        }
        else rotate(x) , rotate(x);
    }
    if(!isroot(x)) rotate(x);
}

int t;

inline void access(int x) {
    t = 0;
    while(x) {
        splay(x);
        ch[x][1] = t;
        t = x;
        x = fa[x];
    }
}

inline void make_root(int x) {
    access(x); splay(x); rev[x] ^= 1;
} 

inline void link(int x,int y) {
    make_root(x); fa[x] = y;
}

inline void cut(int x ,int y) {
    make_root(x);
    access(y);
    splay(y);
    fa[x] = ch[y][0] = 0;
}

int Find(int x) {
    access(x);
    splay(x);
    while(ch[x][0]) x = ch[x][0];
    // 人工找联通快的最高点 
    return x;
}

int main() {
    scanf("%d%d",&n,&m);
    for(int i = 1;i <= m;i ++) {
        scanf("%s",ty);
        scanf("%d%d",&x,&y);
        if(ty[0] == 'Q') {
            if(Find(x) == Find(y)) {
                puts("Yes");
            }
            else puts("No");
        }
        if(ty[0] == 'C') link(x,y);
        if(ty[0] == 'D') cut(x,y);
    }
}

BZOJ 2002 弹飞绵羊，查询深度。

%:pragma GCC optimize(2)
#include<bits/stdc++.h>

using namespace std;

const int N = 200005;
int n;
int fa[N] , ch[N][2] , S[N] , a[N];
bool rev[N];

void pushup(int x) {
    S[x] = S[ch[x][0]] + S[ch[x][1]] + 1;
}

void pushdown(int x) {
    if(rev[x]) {
        rev[ch[x][0]] ^= 1;
        rev[ch[x][1]] ^= 1;
        swap(ch[x][0],ch[x][1]);
        rev[x] = 0;
    }
}

int dir(int x) {
    return (x == ch[fa[x]][1]);
}

bool isroot(int x) {
    return ((ch[fa[x]][0] != x) && (ch[fa[x]][1] != x));
}

void rotate(int x) {
    int F = fa[x] , GF = fa[F];
    int dir_x = dir(x);
    if(!isroot(F)) ch[GF][dir(F)] = x;
    fa[x] = GF; fa[F] = x;
    ch[F][dir_x] = ch[x][!dir_x];
    if(ch[x][!dir_x])fa[ch[x][!dir_x]] = F;
    ch[x][!dir_x] = F;
    pushup(F);pushup(x);
}

void splay(int x) {
    stack<int>F;
    while(!F.empty()) F.pop();
    F.push(x);
    //* * * warning* * *//
    for(int i = x;!isroot(i);i = fa[i]) F.push(fa[i]);
    while(!F.empty()) {
        int V = F.top(); F.pop();
        pushdown(V);
    }
    while(!isroot(x) && !isroot(fa[x])) {
        if(dir(fa[x]) == dir(x)) {
            rotate(fa[x]); rotate(x);
        }
        else rotate(x) , rotate(x);
    }
    if(!isroot(x)) rotate(x);
}

//简略写法。 

void access(int x) {
    int t = 0;
    while(x) {
        splay(x);
        ch[x][1] = t;
        pushup(x);
        t = x;
        x = fa[x];
    }
}

void make_root(int x) {
    access(x); splay(x); rev[x] ^= 1;
}

void link(int x,int y) {
    make_root(x); fa[x] = y;
}

void cut(int x ,int y) {
    make_root(x);access(y);
    splay(y);
    ch[y][0] = fa[x] = 0 ,pushup(y);
}

int find(int x) {
    access(x);
    splay(x);
    while(ch[x][0]) x = ch[x][0];
    return x;
}

int main() {
    scanf("%d",&n);
    int ty , x , y;
    for(int i = 1;i <= n;i ++) {
        scanf("%d",&a[i]);
        link(i,min(i+a[i],n+1));
    }
    int q;scanf("%d",&q);
    for(int i = 1;i <= q;i ++) {
        scanf("%d%d",&ty,&x);
        x ++;
        if(ty == 1) {
            make_root(n + 1);
            access(x);splay(x);
            printf("%d\n",S[x] - 1);
        }
        else {
            scanf("%d",&y);
            cut(x,min(n + 1, x+ a[x]));
            link(x,min(n + 1, x+ y));
            a[x] = y;
        }
    }
}
Timsei
关注
【动态树问题】LCT学习笔记
CreationAugust is 14 years old forever
08-10 2090
我竟然还不会LCT QAQ真是太弱了 必须学LCT QAQ ——————————————————线割分是我www———————————-
LCT 学习笔记
永爱米蒂
08-10 291
文章目录引入 引入 LCT是什么？ Li-Chao-Tree？这和李超线段树有关么？ 先看一道题目。 Luogu P3690 首先，看到树上的路径，我们首先想到的是线段树套重链剖分。但是，连边、删边又是什么鬼？ 可能，我们需要一种新的算法，能完成线段树套重链剖分的东西，又能完成连边和删边。 明眼人都知道，底子肯定不可能是重链剖分，难道是长链剖分？ 两个都不是，因为我们需要连边删边，一更改不管你是...
splay&LCT学习笔记
White_gugu的博客
01-25 282
伸展树(splay)和Link-Cut Tree
lct303-311-Artificial-Intelligence-测试笔记
最新发布
07-28
lct
（DKBY）DFL学习笔记
qq_67004876的博客
07-19 2152
DFL学习笔记
相关滤波目标跟踪算法以及评价
02-20
1.基于追踪无人机的目标跟踪介绍；2.OTB、VOT指标介绍；3.MOSSE、KCF、DSST、FDSST、LCT等相关滤波跟踪算法的流程对比；4.提出一种基于FDSST和LCT的长期跟踪新算法思路。50页PPT每页都有详细注释！适合学习以及毕业答辩、组会汇报、学术演讲等presentation！
lct学习笔记
平凡的脚步也可以走完伟大的行程。
04-10 597
lct不能够实现“对某个点的子树进行的某些操作”(但可以实现类似求子树大小的简单操作)，然而对于大部分动态树问题来说还是够用了。 主要的四个操作。 1，Access(x)，把原树上x到根路径上的所有点放到同一颗splay里面 2，Makeroot(x)，让x成为所在树的根 3，Cut(x,y)，切断相邻的节点x,y的边 4，Link(x,y)，让x,y连一条树边，成为属于原图的同一棵树。基
LCT ——学习笔记
Lynstery's blog
02-17 2248
终于会LCT了。我原本splay只会写刘汝佳的递归版本，用它写LCT各种烦。。。然后还是去学了一下非递归的。。。 LCT的思想有点类似树链剖分，即把边分为实边和虚边两类。树链剖分是用于静态问题的，没有边的插入删除，而LCT是动态树，显然两者实边和虚边具体定义不同。 LCT的实/虚边是不断变化的，和树链剖分类似，连成一条链的实边路径用splay维护其中的信息。splay序列按点的深度的顺序的，我们
LCT（Link-Cut Tree）学习笔记
P1atform的博客
12-27 465
0LCT（Link-Cut Tree）是一种支持动态维护的树形数据结构，可以用来解决非循环图的动态连通性问题。 这里大概就我的理解去说一下LCT的原理以及实现。 与树剖类似，LCT分为轻/重链，可以保证，重链的条数不超过log(n)log(n)条。 但是，由于链的维护是动态的，这使得我们不能像树剖一样用线段树去维护每一条链。 我们使用splay去维护每一条链，LCT就可以视为是一个splay
LCT（Link Cut Tree）动态树学习笔记
Welcome to yjjr's blog!
12-20 406
动态树LCT就是支持Link，Cut操作的树形数据结构整体思想和树链剖分有些类似，每个点有一条实边（重边）与其儿子相连，剩下的都是虚边（轻边），然后用许多个splay来维护每条重链，记录splay中每个点的父亲节点，那么这个splay的根节点指向的是另一条链（对应的是虚边）下面是LCT的几种基本操作isroot判断这个节点是不是所处的splay的根，代码很显然//c[x][0]表示x节点的左儿子，c
Link Cut Tree（LCT )学习笔记
YxuanwKeith的博客
03-27 3083
先来说一说什么是Link Cut Tree在数据结构中有一类问题叫做动态树问题（DynamicTree）（Dynamic Tree），它会要求你对一颗树进行切割和拼接，然后再在上面维护传统的数据结构能维护的值，为了完成这一类问题，就有了很多相应的算法来解决这类问题，Link Cut Tree就是其中一种比较方便实用的算法。本文讲的就是本人对LCT的一些见解。
LCT学习笔记/基本思路
平凡人Kalzn的博客
09-04 231
我仅一届平凡人 LCT(Link Cut Tree)可以看作是Splay树维护的树链剖分。我们可以在一个动态树上维护树链信息。 重链剖分与实链剖分 在Splay树的基础上，我们定义一条实边： 一个节点的孩子节点指向一个节点，这个孩子节点的fa指针也指向这个节点（即双向边） 相对性的，我们定义一条虚边 一个节点的孩子节点指向一个节点，这个孩子节点的fa指针不指向这个节点（即但向边） 我们把一...
LCT学习笔记（不断更新ing）
某司机的黑车
12-15 993
奇♂妙
LCT动态树学习笔记--基本操作（带详细注释）
caoyang1123的博客
07-15 624
一些LCT最基本也是最核心的操作，其他一些维护树链信息的可以直接参照树链剖分。 #include<bits/stdc++.h> using namespace std; namespace LCT{ struct gg{ int ch[2],fa; bool rev; }node[10010]; void init() {for(int i=0;i<=1000...
动态树问题：LCT与Splay应用
其中，Link-Cut-Tree (LCT) 是解决这类问题的关键技术，由传奇算法学家Tarjan提出，用于处理树的动态更新，而不同于一般的动态树概念。 LCT 建立在Splay树的基础上，但并非简单的套用Splay树的模板。Splay树本身是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值