浅谈LCT

最新推荐文章于 2024-03-06 23:02:28 发布
置顶 最新推荐文章于 2024-03-06 23:02:28 发布
阅读量1.1k 收藏 6
点赞数 2
分类专栏： LCT Splay --------------数据结构----------
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cdy1206473601/article/details/82049074
版权

文章目录

动态树问题, ，近几年在OI中兴起的一种新型问题，是一类要求维护一个有根树森林，支持对树的分割,
合并等操作的问题。由RobertE.Tarjan为首的科学家们提出解决算法Link-Cut Trees，简称lct。

本段摘自百度
要学lct，首先必要的基础必须有：

有了这些基础，我们就可以开始学习lct。

几个概念

  • Preferred Child：偏好儿子
  • Preferred Edge：偏好边
  • Preferred Path：偏好路径

这几个概念跟树链剖分中的重儿子、重边和重链相似。唯一不同的地方就是树链剖分的重儿子、重边和重链是定的，而lct的是不定的，也就是说是没有限制的。
#Auxiliary Tree(辅助树)
其实整棵lct就是又很多个散的splay tree由一些虚边连接而成的，而这些Splay tree就叫做辅助树，在程序实现的时候我们无需实现整棵lct，只需要维护所有Splay tree就好啦。
在lct里的Splay是以深度为键值建的，就是说深度浅的一定在深度深的左边。
#维护什么？

  • son[0~1] 表示每个节点的两个儿子
  • pf表示每个节点的虚边连向的位置（当然不一定每个节点都有）
  • fath 表示每个节点在Splay tree 上的父亲

其实大体上和Splay需要维护的东西不差多少，就多了一个虚边pf，这也是lct比较关键的部分。

接下来我们来了解如何实现lct

lct中的Splay

朴素的Splay操作相信大家已经了解，那在lct中我们需要做什么额外的工作吗？

void rotate(int x){
	int y=t[x].fa,k=get(x);
	if(t[y].fa) t[t[y].fa].son[get(y)]=x;
	if(t[x].son[!k]) t[t[x].son[!k]].fa=y;
	t[y].son[k]=t[x].son[!k],t[x].fa=t[y].fa,t[y].fa=x,t[x].son[!k]=y;
	update(y),update(x),t[x].pf=t[y].pf;
}

rotate操作需要加上最后一句话，使得每次旋转的时候虚边都可以传递。
#核心操作：access(x)
access(x)表示把从x这个点到根的路径上的点全部打成实边，并断掉下面所有的实边。
这里写图片描述
这个图应该比较形象，毕竟是杨哲集训队作业里的。
实现比较简洁明了：

Code

void access(int x){
	for (int y=0;x;update(x),y=x,x=t[x].pf){
		splay(x,0);
		t[t[x].son[1]].fa=0,t[t[x].son[1]].pf=x;
		t[x].son[1]=y,t[y].fa=x,t[y].pf=0;
	}
}

每次把右儿子断开，然后连上刚刚做过的那一个点。

makeroot(x)操作

这个操作的目的就是把x变成这个lct的根。
这里用到Splay中的一个操作：翻转操作
我们首先access(x),使得它到根的路径上变到同一棵Splay上面。
此时x一定是这个Splay上最右边的点，然后就把它旋到根，做一个翻转，这样它就成为了最左边的点，也就是深度最小的点，也就是根。
实现极其简单：

Code：

void make(int x){
	swap(t[x].son[0],t[x].son[1]);
	t[x].tag^=1;
}
void makeroot(int x){
	access(x),splay(x,0);
	make(x);
}

findroot(x)操作

这是用来判断两点是否在同一个连通块上的利器，就像并查集的getfather操作一样，这个实现更简单。首先我们access(x)，这样就可以使得他和根在同一Splay上，然后直接找到Splay最左边的那个点就是了。
实现同样及其简短：

Code

int findroot(int x)
{
	access(x),splay(x,0);
	for (;t[x].son[0];x=t[x].son[0]);
	return x;
}

Link(x,y)操作

使得x，y在lct上连接起来。
首先让x变成根，这样它就没有虚边指向的地方了。
直接上代码，太简短：

Code：

void link(int x,int y){
	makeroot(x);
	if(findroot(y)!=x) t[x].pf=y;
}

Cut(x,y)操作

切断x，y之间的连边。
一样是首先让x变成根，然后access(y)，Splay(y,0)如果他们之间有连边那么x一定是y的儿子，直接断开。

Code：

void cut(int x,int y){
	makeroot(x),access(y),splay(y,0);
	if(t[x].fa==y) t[y].son[get(x)]=t[x].fa=t[x].pf=0;
}

应用：

对于动态边权或动态加边的最小生成树问题。
每次加入一条边的时候考虑已经联通的点对（x,y）我们找到这样一条路径上的一条最长的边，如果当前这条加边小于这条最长的边，我们就直接替换（link+cut）

Exanple

P3690 【模板】Link Cut Tree （动态树）

#include<cstdio>
#include<iostream>
#define maxn 300010
using namespace std;
struct Moon{
	int pf,fa,son[2],key,sum,tag;
}t[maxn]; 
int n,m,kind,d[maxn];
void make(int x){
	swap(t[x].son[0],t[x].son[1]);
	t[x].tag^=1;
}
void update(int x){
	t[x].sum=t[t[x].son[0]].sum^t[t[x].son[1]].sum^t[x].key;
}
void clear(int x){
	if(t[x].tag){
		make(t[x].son[0]),make(t[x].son[1]);
		t[x].tag=0;
	}
}
void remove(int x,int y){
	for (d[0]=0;x!=y;x=t[x].fa) d[++d[0]]=x;
	for (int i=d[0];i>=1;--i) clear(d[i]);
}
int get(int x){
	return t[t[x].fa].son[1]==x;
}
void rotate(int x){
	int y=t[x].fa,k=get(x);
	if(t[y].fa) t[t[y].fa].son[get(y)]=x;
	if(t[x].son[!k]) t[t[x].son[!k]].fa=y;
	t[y].son[k]=t[x].son[!k],t[x].fa=t[y].fa,t[y].fa=x,t[x].son[!k]=y;
	update(y),update(x),t[x].pf=t[y].pf;
}
void splay(int x,int y){
	remove(x,y);
	while(t[x].fa!=y){
		if(t[t[x].fa].fa!=y)
			if(get(x)==get(t[x].fa)) rotate(t[x].fa);
			else rotate(x);
		rotate(x);
	}
}
void access(int x){
	for (int y=0;x;update(x),y=x,x=t[x].pf){
		splay(x,0);
		t[t[x].son[1]].fa=0,t[t[x].son[1]].pf=x;
		t[x].son[1]=y,t[y].fa=x,t[y].pf=0;
	}
}
int findroot(int x)
{
	access(x),splay(x,0);
	for (;t[x].son[0];x=t[x].son[0]);
	return x;
}
void makeroot(int x){
	access(x),splay(x,0);
	make(x);
}
int query(int x,int y){
	makeroot(x),access(y);
	splay(y,0);return t[y].sum;
}
void link(int x,int y){
	makeroot(x);
	if(findroot(y)!=x) t[x].pf=y;
}
void cut(int x,int y){
	makeroot(x),access(y),splay(y,0);
	if(t[x].fa==y) t[y].son[get(x)]=t[x].fa=t[x].pf=0;
}
void change(int x,int y){
	splay(x,0);
	t[x].key=y,update(x);
}
int main(){
	int i,x,y;
	scanf("%d%d",&n,&m);
	for (i=1;i<=n;++i) scanf("%d",&t[i].key);
	while(m--){
		scanf("%d%d%d",&kind,&x,&y);
		if(kind==0)printf("%d\n",query(x,y));
		if(kind==1)link(x,y);
		if(kind==2)cut(x,y);
		if(kind==3)change(x,y);
	}
}

P3203 [HNOI2010]弹飞绵羊

#include<cstdio>
#include<iostream>
#define maxn 200010
#define min(x,y) (((x)<(y))?(x):(y))
using namespace std;
struct Moon{
	int pf,fa,son[2],key,size,tag;
}t[maxn]; 
int n,m,kind,d[maxn];
int get(int x){
	return t[t[x].fa].son[1]==x;
}
void update(int x){
	t[0].size=0;
	t[x].size=t[t[x].son[0]].size+t[t[x].son[1]].size+1;
}
void rotate(int x){
	int y=t[x].fa,k=get(x);
	if(t[y].fa) t[t[y].fa].son[get(y)]=x;
	if(t[x].son[!k]) t[t[x].son[!k]].fa=y;
	t[y].son[k]=t[x].son[!k],t[x].fa=t[y].fa,t[y].fa=x,t[x].son[!k]=y;
	update(y),update(x),t[x].pf=t[y].pf;
}
void change(int x){
	swap(t[x].son[0],t[x].son[1]);
	t[x].tag^=1;
}
void clear(int x){
	if(t[x].tag){
		change(t[x].son[0]),change(t[x].son[1]);
		t[x].tag=0;
	}
}
void remove(int x,int y){
	for (d[0]=0;x!=y;x=t[x].fa) d[++d[0]]=x;
	for (int i=d[0];i>=1;--i) clear(d[i]);
}
void splay(int x,int y){
	remove(x,y);
	while(t[x].fa!=y){
		if(t[t[x].fa].fa!=y)
			if(get(x)==get(t[x].fa)) rotate(t[x].fa);
			else rotate(x);
		rotate(x);
	}
}
void access(int x){
	for (int y=0;x;update(x),y=x,x=t[x].pf){
		splay(x,0);
		t[t[x].son[1]].fa=0,t[t[x].son[1]].pf=x;
		t[x].son[1]=y,t[y].fa=x,t[y].pf=0;
	}
}
void makeroot(int x){
	access(x),splay(x,0);
	change(x);
}
int query(int x){
	makeroot(n+1),access(x);
	splay(x,0);
	return t[x].size-1;
}
void cut(int x,int y){
	makeroot(x);
	access(y);
	splay(y,0);
	t[y].son[get(x)]=t[x].fa=t[x].pf=0;
}
void link(int x,int y){
	makeroot(x),t[x].pf=y;
}
int main(){
	scanf("%d",&n);
	int i,j,x,y;
	for (i=1;i<=n;++i){
		scanf("%d",&t[i].key);
		link(i,min(n+1,i+t[i].key));
	}
	scanf("%d",&m);
	while(m--){
		scanf("%d",&kind);
		if(kind==1){
			scanf("%d",&x);++x;
			printf("%d\n",query(x));
		}
		if(kind==2){
			scanf("%d%d",&x,&y);x++;
			cut(x,min(n+1,x+t[x].key));
			t[x].key=y;
			link(x,min(n+1,x+t[x].key));
		}
	}
}

【NOIP2018模拟A组9.25】到不了

#include<cstdio>
#include<iostream>
#include<cstring>
#define maxn 100010
#define maxm 100010
#define maxq 100010
using namespace std;
int n,m,q,tot;
int root[maxm],d[maxn];
struct Moon{
	int pf,fa,son[2],tag;
}t[maxn];
int fa[maxn];
void make(int x){
	swap(t[x].son[0],t[x].son[1]);
	t[x].tag^=1;
}
void clear(int x){
	if(t[x].tag){
		make(t[x].son[0]),make(t[x].son[1]);
		t[x].tag=0;
	}
}
void remove(int x,int y){
	for (d[0]=0;x!=y;x=t[x].fa) d[++d[0]]=x;
	for (int i=d[0];i>=1;--i) clear(d[i]);
}
int get(int x){
	return t[t[x].fa].son[1]==x;
}
void rotate(int x){
	int y=t[x].fa,k=get(x);
	if(t[y].fa) t[t[y].fa].son[get(y)]=x;
	if(t[x].son[!k]) t[t[x].son[!k]].fa=y;
	t[y].son[k]=t[x].son[!k],t[x].fa=t[y].fa,t[y].fa=x,t[x].son[!k]=y;
	t[x].pf=t[y].pf;
}
void splay(int x,int y){
	remove(x,y);
	while(t[x].fa!=y){
		if(t[t[x].fa].fa!=y)
			if(get(x)==get(t[x].fa)) rotate(t[x].fa);
			else rotate(x);
		rotate(x);
	}
}
int access(int x){
	int z;
	for (int y=0;x;y=x,x=t[x].pf){
		splay(x,0);
		t[t[x].son[1]].fa=0,t[t[x].son[1]].pf=x;
		t[x].son[1]=y,t[y].fa=x,t[y].pf=0,z=x;
	}
	return z;
}
int Get(int x){
	if(fa[x]==x) return x;
	return fa[x]=Get(fa[x]);
}
void makeroot(int x){
	access(x);
	splay(x,0);
	make(x);
}
void link(int x,int y){
	makeroot(y);
	int xx=Get(x),yy=Get(y);
	if(xx!=yy) fa[xx]=yy,t[y].pf=x;
}
int findans(int x,int y){
	if(Get(x)!=Get(y)) return -1;
 	int q=access(y);
	int p=access(x);
	return p;
}
int main(){
	freopen("arrival.in","r",stdin);
	freopen("arrival.out","w",stdout);
	scanf("%d %d",&n,&m);
	int i,j,x,y,kind,ans;
	for (i=1;i<=m;++i) scanf("%d",&root[i]);
	for (i=1;i<=n;++i) fa[i]=i;
	for (i=1;i<=n-m;++i){
		scanf("%d %d",&x,&y);
		link(x,y);
 	}
 	for (i=1;i<=m;++i) makeroot(root[i]);
	scanf("%d",&q);
	while(q--){
		scanf("%d%d%d",&kind,&x,&y);
		if(kind==1){
			if(Get(x)!=Get(y))link(x,y);
		}
		else{
			ans=findans(x,y);
			if(ans==-1) printf("orzorz\n");
			else printf("%d\n",ans);
		}
	}
}
Chandery
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
lct_LCT_
09-29
标题中的“lct_LCT_”很可能代表“Link-Cut Tree”，这是一项在计算机科学领域，特别是算法设计中广泛使用的数据结构。Link-Cut Tree（链接切割树）是一种自顶向下的动态树数据结构，主要用于解决与树相关的操作，如...
LCT（link-cut-tree）入门
gigo_64 sink in my world
02-15 1412
ps：由于博主的qwq，把很多实边写成了实链，大家就将就着看吧嘿嘿。 LCT，全称动态树，用于应付不断地加边删边的树的一种算法，非常非常优秀。 因为其经典操作link和cut而被叫做link cut tree（是吗？？猜的） emm link:链接，cut:砍掉（滑稽） 现在我们开始。（先声明LCT维护的是一个森林哈！） 引入：仨链剖分 我们一般提到的三种剖分是：重链剖分，实链剖分，...
动态树之Link-Cut-Tree（LCT）详解
GROZAX的博客
04-15 503
树是指一类问题，通常要求对一片森林进行路径查找与修改、增删边、维护连通性、路径上的权值和等信息等操作，它与树链剖分的区别在于需要维护边的删除和添加。动态树有很多种解决方法，我们今天只介绍适用范围最广、最常用的一种解法：Link-Cut-Tree（LCT）。
史上最详尽的LCT讲解
薇小薇
11-23 6854
终于填完了这个天坑！
浅谈算法——LCT
Canopus
09-04 6318
前置技能 splay: 必须 树链剖分: 可选，知道树链剖分会容易理解一些。 以下大部分图片来自https://blog.csdn.net/saramanda/article/details/55253627 Link Cut Tree(LCT) LCT，又叫林克-卡特树，可以用来解决动态树问题。 LCT显然是一棵树，它长这样： 这上面有一些粗一点的边，我们把它称为重边；还有...
Long-term Correlation Tracking LCT目标跟踪算法原理详解（个人学习笔记）
最新发布
CHEN77的博客
03-06 1299
目录1. 算法总览2. 算法详解2.1. 基础相关滤波跟踪2.2. 各模块详解2.2.1. 相关跟踪2.2.2. 在线检测器3. 算法实现3.1. 算法步骤3.2. 实现细节4. 相关讨论&总结 1. 算法总览 LCT的总体流程如上图所示，其思想为：将长时跟踪（long-term tracking）分解为对运动目标的平移（translation）估计和尺度（scale）变化估计，再配置一个检测器（detector），以实现re-detection。 其主要包含三个模块，即图中标红的部分，分别为：
lct.zip_LCT
09-19
【标题】"lct.zip_LCT" 涉及到的是一个名为 "lct.zip" 的压缩文件，其中包含了与"LCT"相关的资料。LCT通常代表“逻辑控制技术”（Logical Control Technology）或者“线性电流变换器”（Linear Current Transformer...
lct.zip_lct文件
09-24
标题中的“lct.zip_lct文件”指的是一个压缩包，其中包含了名为“lct”的文件。这个“lct”文件可能是一个库文件，用于在特定的编程环境或项目中提供预定义的功能，使得开发者能够更方便地进行软件开发，而无需从零...
动态树LCT BySemiWaker
03-05
动态树LCT
元器件应用中的LCT型陷波器
11-23
LCT型陷波器在电子工程领域中是一种重要的滤波元件，主要用于消除特定频率范围内的干扰信号，确保信号传输的纯净度。这种陷波器的设计和应用涉及到许多关键的电气特性，包括频率响应、带宽、插入损耗以及选择性等。 ...
TLD跟踪算法源码及解析
08-23
TLD跟踪算法在vs2012+opencv2.4.5环境下的C++源码
【XSY2741】网格 分治 LCT 并查集
weixin_30657541的博客
03-10 134
题目描述 　　有一个\(n\times m\)的网格，线框的交点可以扭动，边不可伸缩。网格中有一些格子里面放了'x'形的支架，这些格子不会变形，但可以整体转动。如果所有格子都不能变形，那么称这个网格稳固。 　　有\(q\)个操作，每次改变一个格子的状态，即有支架给为无支架，无支架改为有支架。 　　请你判断初始及每次操作后这个网格是否稳固。 　　比如说下面这个网格就不稳固。 　　\(n,m\leq...
win10在MATLAB中运行LCT算法
weixin_44292294的博客
05-24 296
win10在MATLAB2021b中运行LCT算法 参考： 1、LCT代码跑起来先文章思路总结 1、代码下载： 作者给出的代码：LCT 2、配置依赖： 2.1、vl_feat toolbox 下载依赖库 vl_feat toolbox：vl_feat toolbox 根据LCT代码跑起来先文章思路总结给出的步骤，下载对应的包，然后解压，运行文件，添加到路劲 2.2、opencv 下载安装opencv：opencv 修改utility文件夹里边的compile.m： 这样直接编译，会报错： 把下载的ope
长期跟踪经典之作2--- LCT 算法论文阅读与代码运行
skywalker_123的博客
05-09 6349
好了  TLD很费劲地弄完了，现在开始进阶的SHJT大神的LCT，就是长期追踪，我相信未来这个方向会火起来的。   这两天琢磨完了论文，这里罗列一下读论文主要需要参阅的： 1 STC （用到了时空上下文分析定位） 2 DSST fDSST （用到了位置与尺度相关滤波器与一系列特征维度） 3 TLD （long term经典之作，LCT用到了RF的fern分类检测） 4 STRUCK ...
LCT
attack666的博客
06-29 4531
前置知识 必须要理解splay 最好学过树链剖分 博客设置基础定义 LCT是一种解决动态树问题的方法，由tarjan~~(为什么又是他)~~在1982年提出，最原始的论文在这里,在论文中，tarjan除了介绍了均摊复杂度为O(log2n)O(log2n)O(log^2n)的LCT之外，还介绍了一种严格O(log2n)O(log2n)O(log^2n)的算法，不过本人太弱了，看不懂ta...
动态树~LCT总结
热门推荐
Senbonzakura
06-26 1万+
这是我开的一套动态树专题：http://acm.hust.edu.cn/vjudge/contest/view.action?cid=25242#overview 首先说一下什么是动态树。动态树可以维护一个动态的森林，支持树的合并（两棵合并成一棵），分离（把某个点和它父亲点分开），动态LCA，树上的点权和边权维护、查询（单点或者树上的一条路径），换根。 这里首先推荐杨哲的集训队作业：http:
LCT学习笔记
TA
03-31 2495
一、什么是势能分析？ 势能分析首先要有一个势能函数F(S)，S是一个数据结构集合，是你要分析的所有数据结构的集合，比如说你要分析一坨splay/lct森林的时间复杂度，那么f就是splay/lct森林的势能函数，而不仅仅是一棵splay/lct，虽然它也可以是。 对于每一次操作，我们进行这样的放缩：实际运行代价+势能改变量 ≤G(n)(n=|S|)。G(n)是一个比较良性的函数。那么我们把所有操
LCT介绍
WJSZMRX
07-07 1193
偶然看到了LCT,发现好多东西都忘了，今天就来写写LCT总结吧。 LCT=link-cut-tree 在树链剖分里我们把树按dfs序换成连续序列，再来解决树上两点间路径操作的问题。很明显，假如树的结构变了，那么原来的树链剖分就GG了。为了解决可以增边的问题我们引进LCT。 LCT的基本思想就是把树链剖分里的重块都存到一颗splay里，以splay的灵活性来解决删边加边的问题（无论原图怎么删都得
【目标跟踪】Long-term Correlation Tracking 阅读笔记
工药叉的经文
03-07 6557
Long-term Correlation Tracking 论文地址： https://www.cv-foundation.org/openaccess/content_cvpr_2015/papers/Ma_Long-Term_Correlation_Tracking_2015_CVPR_paper.pdf long_term_tracking tracking 阅读笔记 L...
动态树问题：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、付费专栏及课程。

余额充值