LCT动态树学习笔记--基本操作（带详细注释）

已于 2022-03-17 23:27:12 修改
阅读量593 收藏
点赞数 1
分类专栏： 笔记 文章标签： 学习 c++ 算法
于 2018-07-15 21:36:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/caoyang1123/article/details/81056920
版权

一些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<=10000;i++)node[i].ch[0]=node[i].ch[1]=node[i].fa=node[i].rev=0;}//毫无卵用的清空 
	int get(int x)//询问该点是父亲的左儿子或右儿子或都不是（都不是即该点为所在splay的根，通过轻边单向连父亲） 
	{
		if(!node[x].fa)return -1;
		if(node[node[x].fa].ch[0]==x)return 0;
		if(node[node[x].fa].ch[1]==x)return 1;
		return -1;
	}
	void push_down(int x)//下放翻转标记，同普通splay 
	{
		if(x&&node[x].rev)
		{
			node[node[x].ch[0]].rev^=1;
			node[node[x].ch[1]].rev^=1;
			swap(node[x].ch[0],node[x].ch[1]);
			node[x].rev=0;
		}
	}
	void push(int x)//下放x点到所在splay的根的所有标记 
	{
		if(get(x)!=-1)push(node[x].fa);
		push_down(x);
	}
	void rotate(int x)//splay基本操作，注意判断父亲是所在splay根的情况 
	{
		int fx=node[x].fa,gx=node[fx].fa,op=get(x),fop=get(fx);
		node[fx].ch[op]=node[x].ch[op^1],node[node[x].ch[op^1]].fa=fx;
		node[x].fa=gx;if(fop!=-1)node[gx].ch[fop]=x;
		node[x].ch[op^1]=fx,node[fx].fa=x;
	}
	void splay(int x)//splay基本操作，注意先下放标记 
	{
		push(x);
		for(int fx=node[x].fa;get(x)!=-1;rotate(x),fx=node[x].fa)
		{
			if(get(fx)!=-1)
			{
				(get(x)==get(fx))?rotate(fx):rotate(x);
			}
		}
	}
	void access(int x)//最重要操作，即我在前一篇说的更改轻重链，它能将x节点与整棵树根（不是所在splay）连到一个重链里
//并且x节点和儿子都以虚边连接以支持换根
	{
		for(int y=0;x;)
		{
			splay(x);//先转到当前splay的根 
			node[x].ch[1]=y;//右儿子断开，变为上次转到splay的点 
			y=x,x=node[x].fa;//更新 
		}
	}
	void make_root(int x)//换根操作，令x成为整棵树根（基于access后x为所在splay最深点性质） 
	{
		access(x),splay(x),node[x].rev^=1;//打标记是因为x变为根后它的深度要变为最小，因此需翻转 
	}
	void split(int x,int y)//把x与y的路径组成一个以y为根的splay
	{
		make_root(x),access(y),splay(y);
	}
	void cut(int x,int y)//把x与y分离 
	{
		split(x,y);
		node[x].fa=node[y].ch[0]=0;
	}
	void line(int x,int y)//连接x，y 
	{
		make_root(x),node[x].fa=y;
	}
	int find(int x)//查找x点所在树的根节点 
	{
		for(access(x),splay(x);node[x].ch[0];x=node[x].ch[0]);
		return x;
	}
}
using namespace LCT;
int main()
{
	int n,m,x,y;char op[20];
	scanf("%d%d",&n,&m);
	init();
	while(m--)
	{
		scanf("%s",op);
		scanf("%d%d",&x,&y);
		if(op[0]=='Q')find(x)==find(y)?puts("Yes"):puts("No");
		else if(op[0]=='C')line(x,y);
		else if(op[0]=='D')cut(x,y);
	}
}

upd:

登录—专业IT笔试面试备考平台_牛客网

维护到根路径上点权最值，优化码风（看以前的代码写成一坨跟yzy一样，真是难受）

#include<bits/stdc++.h>
#define pii pair<int,int>
#define fi first
#define sc second
#define pb push_back
#define ll long long
#define trav(v,x) for(auto v:x)
#define all(x) (x).begin(), (x).end()
#define VI vector<int>
#define VLL vector<ll>
#define pll pair<ll, ll>
#define double long double
#define int long long
using namespace std;
const int N = 1e6 + 100;
const ll inf = 1e9;
const ll mod = 998244353;//1e9 + 7;

#ifdef LOCAL
void debug_out(){cerr << endl;}
template<typename Head, typename... Tail>
void debug_out(Head H, Tail... T)
{
	cerr << " " << to_string(H);
	debug_out(T...);
}
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif

namespace LCT{
	#define ls ch[0]
	#define rs ch[1]
	int tot;
	struct gg{
		int ch[2], fa, las, val, mx, ps;
		bool rev;
		void in(int x, int y)
		{
			las = x, val = y, ps = tot;
			ch[0] = ch[1] = fa = mx = 0;
			rev = 0;
		}	
	}node[N];
	void init()
	{
		for(int i = 0; i <= tot; i++)
		{
			node[i].ch[0] = node[i].ch[1] = node[i].fa = node[i].rev = 0;
			node[i].val = node[i].las = node[i].mx = 0;
		}
		tot = 0;
	}//毫无卵用的清空 
	int get(int x)//询问该点是父亲的左儿子或右儿子或都不是（都不是即该点为所在splay的根，通过轻边单向连父亲） 
	{
		if(!node[x].fa)
			return -1;
		if(node[node[x].fa].ch[0]==x)
			return 0;
		if(node[node[x].fa].ch[1]==x)
			return 1;
		return -1;
	}
	void push_up(int x)
	{
		node[x].mx = node[x].val, node[x].ps = x;
		int l = node[x].ls, r = node[x].rs;
		if(l && node[x].mx < node[l].mx)
			node[x].mx = node[l].mx, node[x].ps = node[l].ps;
		if(l && node[x].mx == node[l].mx && node[x].ps < node[l].ps)
			node[x].mx = node[l].mx, node[x].ps = node[l].ps;
		swap(l, r);
		if(l && node[x].mx < node[l].mx)
			node[x].mx = node[l].mx, node[x].ps = node[l].ps;
		if(l && node[x].mx == node[l].mx && node[x].ps < node[l].ps)
			node[x].mx = node[l].mx, node[x].ps = node[l].ps;
	}
	void push_down(int x)//下放翻转标记，同普通splay 
	{
		if(x && node[x].rev)
		{
			node[node[x].ch[0]].rev^=1;
			node[node[x].ch[1]].rev^=1;
			swap(node[x].ch[0],node[x].ch[1]);
			node[x].rev=0;
		}
	}
	void push(int x)//下放x点到所在splay的根的所有标记 
	{
		if(get(x) != -1)push(node[x].fa);
		push_down(x);
	}
	void rotate(int x)//splay基本操作，注意判断父亲是所在splay根的情况 
	{
		int fx = node[x].fa, gx = node[fx].fa, op = get(x), fop = get(fx);
		node[fx].ch[op] = node[x].ch[op ^ 1], node[node[x].ch[op ^ 1]].fa = fx;
		node[x].fa = gx;
		if(fop!=-1)
			node[gx].ch[fop] = x;
		node[x].ch[op ^ 1] = fx, node[fx].fa = x;
		push_up(fx);
		push_up(x);
	}
	void splay(int x)//splay基本操作，注意先下放标记 
	{
		push(x);
		for(int fx = node[x].fa; get(x) != -1; rotate(x), fx = node[x].fa)
		{
			if(get(fx)!=-1)
			{
				(get(x)==get(fx))?rotate(fx):rotate(x);
			}
		}
	}
	void access(int x)//最重要操作，即我在前一篇说的更改轻重链，它能将x节点与整棵树根（不是所在splay）连到一个重链里
//并且x节点和儿子都以虚边连接以支持换根
	{
		for(int y = 0; x;)
		{
			splay(x);//先转到当前splay的根 
			node[x].ch[1] = y;//右儿子断开，变为上次转到splay的点 
			push_up(x);
			y = x, x = node[x].fa;//更新 
		}
	}
	void make_root(int x)//换根操作，令x成为整棵树根（基于access后x为所在splay最深点性质） 
	{
		access(x), splay(x), node[x].rev ^= 1;//打标记是因为x变为根后它的深度要变为最小，因此需翻转 
	}
	void split(int x, int y)//把x与y的路径组成一个以y为根的splay
	{
		make_root(x), access(y), splay(y);
	}
	void cut(int x,int y)//把x与y分离 
	{
		split(x,y);
		node[x].fa = node[y].ch[0] = 0;
	}
	void line(int x,int y)//连接x，y 
	{
		node[x].fa=y;
	}
	int find(int x)//查找x点所在树的根节点 
	{
		for(access(x), splay(x); node[x].ch[0]; x = node[x].ch[0]);
		return x;
	}
	int find_ps(int x)
	{
		split(x, 1);
		if(node[1].mx <= 0)
			return -1;
		return node[1].ps;
	}
}
using namespace LCT;

int idx[N];
int qq;

pll ask(int x, int y)
{
	ll res = 0, num = 0;
	while(y)
	{
		int ps = find_ps(x);
		//cerr << ps << ' ' << node[ps].val << ' ' << node[ps].las << '\n';
		if(ps < 0)
			break;
		int tmp = min(node[ps].las, y);
		node[ps].las -= tmp;
		y -= tmp;
		num += tmp;
		res += 1LL * node[ps].val * tmp;
		if(node[ps].las == 0)
		{
			make_root(ps);
            node[ps].las = 0;
            node[ps].val = -1;
            node[ps].mx = -1;
		}
	}
	return pll(res, num);
}

void sol()
{
	tot = N - 1;
	init();
	idx[0] = 1;
	cin >> qq;
	int x, y;
	cin >> x >> y;
	node[++tot].in(x, y);
	ll ans = 0;
	//cerr << node[1].fa << '\n';
	for(int i = 1; i <= qq; i++)
	{
		int op;
		cin >> op;
		if(op == 1)
		{
			int fa;
			cin >> fa;
			fa = (fa + ans) % i;
			fa = idx[fa];
			cin >> x >> y;
			idx[i] = ++tot;
			node[tot].in(x, y);
			//cerr << ">>" << fa << ' ' << x << ' ' << y << '\n';
			line(tot, fa);
		}
		else
		{
			cin >> x >> y;
			pll cur = ask(idx[x], y);
			//cerr << "!!" << cur.sc << ' ' << cur.fi << '\n';
			cout << cur.sc << ' ' << cur.fi << '\n';
			ans = cur.sc + cur.fi;
		}
	}
}

signed main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
//	int tt;
//	cin >> tt;
//	while(tt--)
		sol();
}

caoyang1123
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
动态树 LCT（Link-Cut-Tree）--入门教程
yashem66
12-12 3901
什么是LCT（Link-Cut-Tree）根据杨哲先生的论文（QTREE），可以得知，动态树问题是一类问题的统称，而解决这种问题最常用到的数据结构就是LCT（Link-Cut-Tree）。LCT的大体思想类似于树链剖分中的轻重链剖分，轻重链剖分是处理出重链来，由于重链的定义和树链剖分是处理静态树所限，重链不会变化，变化的只是重链上的边或点的权值。由于这个性质，我们用线段树来维护树链剖分中的重链，但是
【持续更新】LCT学习笔记
Brute♂force
08-17 406
前言 之前没怎么打过LCT，这次来苏州集训乘机补一个坑 LCT功能十分强大，它可以维护一个森林的一系列问题 LCT的结构 一句话来说，就是对于森林里的每棵树做轻重链剖分，每条重链用splay维护 LCT基本操作 Access 这是LCT最关键的操作 access(x)是把x弄到与根在同一个splay上的操作，也就是把x到根的虚边全部变实边过程大概是： 将x splay到x所属平衡树的根 令x的右儿子为x’(初始x’=NULL)这相当于把虚边边实边 令x’=x x=fa[x]重复上述过程，直到跳到根 上代
LCT动态树学习笔记--个人理解
caoyang1123的博客
07-15 258
LCT，即link-cut-tree，用于解决动态树这一类问题，思想上和树链剖分相近，树链剖分通过重链剖分将树划分为轻重链，而之后一般通过线段树进行维护。而LCT则也将树分为两种边（姑且也称作轻重边，反正是个名字而已），但并不通过子节点sz划分，而是一种相对的划分。其通过splay维护当前一棵树中的重链（即一棵splay里所有节点是某一棵树的某一重链），而轻链用于连接一棵树里的splay。spla...
ECO跟踪算法源码
10-12
ECO跟踪算法源码，来源于CVPR2017会议，ECO是C-COT的加速版，从模型大小、样本集大小和更新策略三个方便加速，速度比C-COT提升了20倍，加量还减价，EAO提升了13.3%，最最最厉害的是， hand-crafted features的ECO-HC有60FPS
【动态树】【Link Cut Tree】动态树的理解（入门）
weixin_30872337的博客
04-07 309
引入 现在我们需要一个数据结构满足支持以下的操作： 两个节点连接（保证不出现环） 两个节点断开 求任意两个节点之间的区间和 这样是不是很像树链剖分？ 但是因为是动态的所以我们采用动态树来进行维护。 样例 现在给出一个样例，我们一下的解释都以当前样例为模板 我们有三个节点1 2 3 4，现在他们是连接在一起的如下图 为什么有一个虚线呢，这里我们用虚线表示...
动态树LCT BySemiWaker
03-05
动态树LCT
LCT.rar_LCT_lct-ofdm_power line _峰均功率比_峰均比
最新发布
09-19
标题中的“LCT.rar_LCT_lct-ofdm_power line_峰均功率比_峰均比”指的是一个关于LCT（Lapped Continuous Transform）在OFDM（Orthogonal Frequency Division Multiplexing，正交频分复用）系统中应用于降低峰均功率...
LCT-AT大的TM WL脱壳视频及脚本打包
08-06
LCT-AT大的TM WL脱壳视频及脚本打包 1.0
lct-ui:LCT v4 用户界面
06-03
**标题详解：**"lct-ui:LCT v4 用户界面" LCT UI 是一个专为 LCT（可能是某个软件或系统的缩写）设计的用户...项目源代码可以在"lct-ui-master"这个主分支中获取，适合前端开发者研究、学习或参与到项目的开发中去。
U2000 LCT 用户指南-(V100R005C00_01).
05-23
U2000 LCT 用户指南-(V100R005C00_01).
LCT入门（动态树）（点权）（边权）
qq_2992427261
09-23 1876
LCT的用途： 1，在线链接link&cut（连接边，删除边） 2，查询连通性 3，维护链上信息 4，换根 5，维护子树信息。 等等： 基础知识： 1.伸展树（Splay Tree） ：支持链上求和，求最值，修改，等等操作， 2LCT（link cut tree）：是一棵树，长这样： 这上面有一些粗一点的边，我们把它称为重边；还有一些细一点的，我们把它称为轻边。 基本函数功能介绍： ac...
目标跟踪（一）：Visual Object Tracking using Adaptive Correlation Filters(MOSSE Filter)
sannianyihoushuma的博客
12-22 201
https://blog.csdn.net/StayFoolish_Fan/article/details/53066673
LCT学习笔记
weixin_30586257的博客
01-11 108
为啥要学LCT啊 在开坑之间，我们来先看一段对话： Q：给你一颗森林，现在不断的连接森林中的两棵树，保证不连出环，多次问你某两个点的连通性？ A（dalao&蒟蒻）：这不是SB题吗？显然并查集水过啊。 Q：说的好，但是如果我要删除某些边呢？ A（dalao）：那就可持久化并查集啊，你的问题怎么那么水。 A（蒟蒻）：........（发出gg的声音） 这时候，如果我们并不...
Link Cut Tree（LCT )学习笔记
YxuanwKeith的博客
03-27 3043
先来说一说什么是Link Cut Tree在数据结构中有一类问题叫做动态树问题（DynamicTree）（Dynamic Tree），它会要求你对一颗树进行切割和拼接，然后再在上面维护传统的数据结构能维护的值，为了完成这一类问题，就有了很多相应的算法来解决这类问题，Link Cut Tree就是其中一种比较方便实用的算法。本文讲的就是本人对LCT的一些见解。
板子：LCT（现在都不敢说自己写的是学习笔记了）
少主大人殿下的博客
03-27 807
以后Splay就只记LCT的，其他的用treap 简述 LCT的大概思想是这样的： 每一条重链都是一颗Splay，其中深度为键值（要把握住它是一条连，而且键值不会重复） 同一重链结点之间的连边是通过Splay内部连边完成的 轻边是通过Splay的根结点的父亲连接，但是该父亲不会指向该根结点（著名的儿子认父亲，父亲不认儿子问题） （Splay的根结点的父亲是Splay在原树中顶端结...
LCT学习总结
gankinghand的博客
08-11 318
并不打算详细讲，别人的博客已经讲得非常好了。 FlashHu的blog 正题 实链剖分与树剖类似，将某一儿子的连边设为实边，其余的设为虚边，关键在于虚实是可以改变的，因此要用splay来搞。注意LCT维护对象是森林。 access access之后记得update，而且access之后x不一定是splay的根 rotate 因为这是lct所以我们的splay变得有些不一样了。 void rotat...
[学习笔记]LCT进阶操作
weixin_33681778的博客
12-18 174
LCT总结——应用篇（附题单）（LCT） 一般都是维护链的操作。split即可搞定。 进阶操作的话，处理好辅助树和原树的关系即可搞定。 其实，最大的区别就是，splay随便转，辅助树形态变了，但是原树形态不变，makert会让原树形态变化 LCT维护子树信息 真儿子会splay的时候各种变化，但是虚儿子只会在access和link的时候发生变化，其他的时候可以理解为跟着转。 以处...
Flex 动态树详解
zxd7900663的博客
10-15 144
搞了大半天终于把FLEX异步树实现了，效果先说明一下：页面初始化时只显示一个根目录（左边没有三角按钮可以点击），我是用tree控件的change方法触发事件的，然后通过远程对象调用java方法从数据库查出该目录的下一级目录，返回给flex显示。 下面看代码： java端：简单，就一个根据目录id查询该目录的所有下一级目录 [code="java"]/** * 返回的XML格式...
LCT 学习笔记
永爱米蒂
08-10 268
文章目录引入 引入 LCT是什么？ Li-Chao-Tree？这和李超线段树有关么？ 先看一道题目。 Luogu P3690 首先，看到树上的路径，我们首先想到的是线段树套重链剖分。但是，连边、删边又是什么鬼？ 可能，我们需要一种新的算法，能完成线段树套重链剖分的东西，又能完成连边和删边。 明眼人都知道，底子肯定不可能是重链剖分，难道是长链剖分？ 两个都不是，因为我们需要连边删边，一更改不管你是...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值