LCT模板 LCT题型大荟萃

以HDU4010为例,写了LCT相关的一些题目的做法

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
using namespace std;
void fre() { freopen("c://test//input.in", "r", stdin); freopen("c://test//output.out", "w", stdout); }
#define MS(x,y) memset(x,y,sizeof(x))
#define MC(x,y) memcpy(x,y,sizeof(x))
#define ls o<<1
#define rs o<<1|1
typedef long long LL;
typedef unsigned long long UL;
typedef unsigned int UI;
template inline void gmax(T1 &a, T2 b) { if (b>a)a = b; }
template inline void gmin(T1 &a, T2 b) { if (binline void gadd(T1 &a, T2 b) { a = (a + b) % Z; }
int casenum, casei;
/*
【算法介绍】
所谓动态树(LCT),从数据结构上讲,其实只不过是splay的扩展。
ACM中的很多问题,都是基于一棵固定形态的树。然而LCT的存在,使得就算树形态发生变化,也可以解决很多询问。
<1> 首先要明确,我们在内部是用splay实现LCT,而在splay中,每个点到根节点距离的期望为log级别,这是LCT复杂度有保障的基础
<2> 在LCT中我们会有很多条preferred path(最多n条,即每点都独属于一条preferred path)。
	对于每条preferred path,以深度为排序关键字,便可以得到一棵splay(我们把这棵splay称作auxiliary tree)
<3> 我们不需要特殊维护所有点所呈的森林结构,森林结构的所有信息都存在splay中
	splay内部的父子关系是由其位置排列的左右来决定的
	splay中的关键词是是深度,所以对于任意一个点x,如果把其转为其所在splay的根,则ch[x][0]就是x的祖先,ch[x][1]就是x的子孙
	即我们需要注意:ch[x][0]并不一定是x的父节点,last(ch[x][0])才是;ch[x][1]并不一定是x的子节点,first(ch[x][1])才是。
	同样,在splay中,fa[x]所指向的节点,并非一定是真实树形态中x的父节点。
	总结一下,就是——在splay中,我们只有通过理清深度关系,才可以明确得到所有点在真实树形态中的父子关系。
	而splay外部,splay的根节点x中存的fa[x],在真实树结构中,就恰好对应为x节点的父节点。

【算法实现】
<1> access(x) 
该操作的功能是取出从x到真实树根直接的所有节点(这些节点一个也不多一个也不少,设为集合S)并链接在splay中
在该函数中,每个节点将沿着fa[]指针一直爬到其所在splay的根节点。
由之前的理论可知,在access()中,沿着fa[]的爬升过程中,不一定是在同一棵splay()中进行的,而可能需要链接起不同的splay。
因此每爬升到一个节点x,我们都对x做splay操作,使得ch[x][0]为x的祖先,ch[x][1]为x的子孙,把ch[x][1]丢掉,其都不属于集合S
同时因为不设计到在ch[x][1]子树内任何一个节点的修改,所以我们需要使得fa[ch[x][1]]保持不变,
而只是在access的路径中,链接ch[x][1]为son(son为从起点向上爬升来的暂时的到树根的链)。
我们发现,如果x到root的路径很长,我们这里爬升的步数就可能很多,对应一个比较大的时间复杂度,也就是论文中所说的糟糕初势能。
但是,因为采用了splay压缩路径,使得复杂度均摊为log级别。通常,我们在access(x)后再做splay(x)操作,使得x变为根方便后续的处理。
<2> find_root(x)
对于find_root(x),只要先access(x),再顺着ch[x][0]向左递归,递归的终点便是root.
<3> make_root(x)
对于make_root(x),只要先access(x),再对x所在整棵splay做reverse,并在翻转整条链之后,把fa[root]赋值给fa[x],使得该splay还具备向其上的splay做转移的条件。
该操作只会影响(x, root)这条路径的深度,并且把首端点的延展传递。形象而言,就像是一只蜈蚣,我们抓住其"脊锥",使得(x, root)转了个头
<4> 对于link(x, y)操作,我们先make_root(x),把其到实际树根的整条链都取出来,再直接使得fa[x] = y就好了。
<7> 对于cut(x, y)操作,我们先make_root(x),再做access(y)操作,使得提取出了链(y, x),把fa[ch[y][0]]和ch[y][0]设为0,即使得y与y的实际父节点删了边
<8> 对于modify(x, y, val)操作,我们先make_root(x),再做access(y)操作,使得提取出了链(y, x),再add(y, val)即可
<9> 对于query(x, y)操作,我们先make_root(x),再做access(y)操作,使得取出了链(y, x),再return 返回关于y的值即可

【要点】
<1> 既然是splay,因为涉及到pushup操作,于是我们必须使得根节点处恰好维护着完全子树的值,操作的点位也要在根处
	同样的道理,只要是设计从根向下遍历,就必须做pushdown操作,LCT中的pushdown写法稍特殊,先找到根再一口气pushdown,可以减少pushdown的次数。
<2> LCT有时候维护的是有根树,此时就不需要执行(也不能执行)make_root操作,但是通过access,就能得到该有根树的祖先。操作在该祖先点上展开即可。

*/

int n;
pairedge[N];
vectora[N];
struct LCT
{
	int ID;
	int ch[N][2], fa[N];
	int v[N];
	int mx[N];
	bool rv[N];
	int ad[N];
	void clear(int x)
	{
		ch[x][0] = ch[x][1] = fa[x] = 0;
		rv[x] = ad[x] = 0;
	}
	int newnode(int val)
	{
		int x = ++ID; clear(x);
		mx[x] = v[x] = val;
		return x;
	}
	inline int D(int x)
	{
		return ch[fa[x]][1] == x;
	}
	bool isroot(int x)
	{
		return ch[fa[x]][0] != x && ch[fa[x]][1] != x;
	}
	void reverse(int x)
	{
		if (x == 0)return;
		swap(ch[x][0], ch[x][1]);
		rv[x] ^= 1;
	}
	void add(int x, int val)
	{
		if (x == 0)return;
		v[x] += val;
		mx[x] += val;
		ad[x] += val;
	}
	void pushup(int x)
	{
		mx[x] = v[x];
		gmax(mx[x], max(mx[ch[x][0]], mx[ch[x][1]]));
	}
	void pushdown(int x)
	{
		if (rv[x])
		{
			reverse(ch[x][0]);
			reverse(ch[x][1]);
			rv[x] = 0;
		}
		if (ad[x])
		{
			add(ch[x][0], ad[x]);
			add(ch[x][1], ad[x]);
			ad[x] = 0;
		}
	}
	void rootdown(int x)
	{
		if (!isroot(x))rootdown(fa[x]);
		pushdown(x);
	}
	void setc(int x, int y, int d)
	{
		ch[x][d] = y;
		if (y)fa[y] = x;
		if (x)pushup(x);
	}
	//旋转操作:旋转使得节点x与其父节点交换位置
	void rotate(int x)
	{
		int f = fa[x];
		int ff = fa[f];
		bool d = D(x);
		bool dd = D(f);
		setc(f, ch[x][!d], d);		
		setc(x, f, !d);				
		if (ch[ff][dd] == f)setc(ff, x, dd); else fa[x] = ff;		
	}
	//旋转操作:把x旋转到其所在splay的根节点
	void splay(int x)
	{
		rootdown(x);
		while (!isroot(x))
		{
			//if (!isroot(fa[x]))pushdown(fa[fa[x]]); pushdown(fa[x]); pushdown(x); // WHY WA
			if (!isroot(fa[x]))rotate(D(x) == D(fa[x]) ? fa[x] : x);
			rotate(x);
		}
	}
	//LCT核心操作:在当前的树形态下,取出x到root路径(preferred path)上的所有点,形成auxiliary tree
	//我们只需要对当前爬升到的点now做splay(now)操作并丢掉其右子树(子孙),过程中自动把祖先的fa[root]转移为了fa[now],继续上跳即可。
	void access(int x)
	{
		for (int son = 0, now = x; now; son = now, now = fa[now])
		{
			splay(now);
			setc(now, son, 1);
		}
		splay(x);
	}
	//LCT基本操作:先找到x所在的auxiliary tree(即preferred path),并查找返回该条路径最小的节点(即根)
	int find_root(int x)
	{
		access(x);
		while (ch[x][0])pushdown(x), x = ch[x][0];
		return x;
	}
	//LCT基本操作:先找到x所在的auxiliary tree(即preferred path),并把x旋转为这条路径的根
	void make_root(int x)
	{
		access(x);
		reverse(x);
	}
	//LCT基本操作,先使得x为真实树的根,再提取出y到x这条路径所表示的splay
	void getlink(int x, int y)
	{
		make_root(x);
		access(y);
	}
	//LCT重要操作:在x与y不在同一棵树的条件下,把x变为子树的根,并把x链接为y的子节点
	void link(int x, int y)
	{
		if (x == y || find_root(x) == find_root(y)) { puts("-1"); return; }
		make_root(x); 
		fa[x] = y;
	}
	//LCT重要操作:在x与y在同一棵树的条件下,把x变为子树的根,并把y与y祖先之间的边彻底断开
	void cut(int x, int y)
	{
		if (x == y || find_root(x) != find_root(y)) { puts("-1"); return; }
		getlink(x, y);
		ch[y][0] = 0; fa[ch[y][0]] = 0;
	}
	//LCT常用操作:在x与y在同一棵树的条件下,把链(x, y)上每个点的权值都+=val
	void modify(int x, int y, int val)
	{
		if (find_root(x) != find_root(y)) { puts("-1"); return; }
		getlink(x, y);
		add(y, val);
	}
	//LCT常用操作:在x与y在同一棵树的条件下,询问链(x, y)上的最大点权
	int query(int x, int y)
	{
		if (find_root(x) != find_root(y))return - 1;
		getlink(x, y);
		return mx[y];
	}
	//LCT DEBUG
	void alldown(int x)
	{
		pushdown(x);
		if (ch[x][0])alldown(ch[x][0]);
		if (ch[x][1])alldown(ch[x][1]);
	}
	void solve()
	{
		mx[ID = 0] = -1e9;
		for (int i = 1; i < n; ++i)scanf("%d%d", &edge[i].first, &edge[i].second);
		for (int i = 1; i <= n; ++i) { int val; scanf("%d", &val); newnode(val); }
		for (int i = 1; i < n; ++i)link(edge[i].first, edge[i].second);
		int q, op, x, y, val;
		scanf("%d", &q);
		for (int i = 1; i <= q; ++i)
		{
			scanf("%d", &op);
			if (op == 1)
			{
				scanf("%d%d", &x, &y);
				link(x, y);
			}
			else if (op == 2)
			{
				scanf("%d%d", &x, &y);
				cut(x, y);
			}
			else if (op == 3)
			{
				scanf("%d%d%d", &val, &x, &y);
				modify(x, y, val);
			}
			else
			{
				scanf("%d%d", &x, &y);
				printf("%d\n", query(x, y));
			}
		}
		puts("");
	}
}lct;
int main()
{
	while(~scanf("%d", &n))
	{
		lct.solve();
	}
	return 0;
}
/*
论文 —— 《SPOJ375 QTREE 解法的一些研究》
概念学习:
<1> 访问
	称一个点被访问过,如果刚刚执行了对这个点的access操作
<2> preferred child
	如果节点x在子树中,最后被访问的节点在子树y中,且y是x的子节点,那么我们称y是x的preferred child
	如果最后被访问的节点就是x本身,那么它没有preferred child,每个点到它preferred child之间的边称作preferred edge
<3> preferred path
	整棵树被划分成了若干条preferred path,我们对于每条preferred path,用每个点的深度作为关键字,用一棵平衡树来维护。
	所以在splay中,每个点左子树中的点,深度都比其小,意为其祖先,都在preferred path中这个点的上方
				  每个点右子树中的点,深度都比其大,意为其子孙,都在preferred path中这个点的下方
<4> Auxiliary Tree
	我们使用splay维护preferred path,把树T分解成若干条preferred path。
	我们只需要知道这些路径之间的连接关系,就可以表示出这棵树T
<5> Link-Cut Tree
	将要维护的森林中的每棵树T表示为若干个Auxiliary Tree,通过Splay中的深度关系,将这些Auxiliary Tree连接起来 的数据结构

HDU4010
[题意]
有一棵n(3e5)个点的树
每个点有一个权值,权值在任何时候都不会超过int范围
有Q(3e5)个操作,操作包括4种类型
1 x y:Link操作
	要求x与y属于两棵不同的树,此时连接x与y,从而使得两棵树合并为一棵
2 x y:Cut操作
	要求x与y属于一棵相同的树,先使得x变为该树的根,再切断y与fa[y]之间的边,使得一棵树分裂为两棵
3 val x y:修改操作
	使得x与y之间路径上所有点权都加val
4 x y:询问操作
	输出x与y路径上点权的最大值
[分析]
LCT的模板题。与之类似的——
SPOJ OTOCI:涉及到单点修改和链上求和,对x做单点修改的时候只要splay(x)即可,并不需要access(x)
HDU5333:涉及到维护链上次大值,虽然代码量大了很多,但是本质都相同

BZOJ2002
[题意]
有1 ~ n共计n(2e5)个点。
对于每个点i,有一个弹跳距离v[i](正整数),如果i + v[i] <= n,则我们在达到 i 点之后会被弹到 i + v[i]点
否则在到达 i 点之后就会被弹飞。有m(1e5)个操作——
1 x:问你从x出发弹多少次会被弹飞
2 x val:改变v[x]为val
[分析]
通常而言,LCT的树边是双向边,这使得在过程中,我们只要确定好了链接关系,任意一点为树根其实都不太影响
但是,有些题中LCT的树边是单向边,此时就不能再使用LCT的make_root()函数了,参见此题——
对于这道题,我们可以把每次弹跳的起点和终点之间连边。形成有向树(也是DAG)。于是——
<1> 对于询问操作,就是问你每个点到其所在树根之间的边数。
<2> 对于修改操作,就是涉及到cut与link两种操作。
需要注意的是,这道题与传统的LCT不同,边是有向边。
但是我们可以把其当做无向边来看,心里上明确跳跃过程是从深度较高的点向深度较低的点进行的就好。
可是在LCT中,我们经常会做make_root(x)这样之类的操作,这实际中是不允许的。
本题中需要实现的函数是cut()和link(),其中——
cut(x, y)的功能是把x与y之间的边删掉,此时我们需要access(x),取出x所在的整条splay(即从x到root的路径)
然后使得x与其祖先的关联性完全断开,即执行ch[x][0] = fa[ch[x][0]] = 0操作
link(x, y)的功能是把x与y之间连边,因为每个点的出度都最多为1.
所以此时显然x应当是其所在splay的祖先,我们只需要splay(x),fa[x] = y即可(access(x)实际也一样)。

HDU5967 2016年中国大学生程序设计竞赛(合肥)小R与手机
[题意]
n(2e5)个点,每个点x最多一个出度指向v[x]。
告诉你初始的链接关系,如果v[x] == 0表示无出度
m(2e5)个操作——
1 x y:使得x指向y
2 x:询问如果从x出发,是否能走到一个终止节点,有则输出,无则输出-1
[分析]
问题还是先分析好再做得好。
这道题的动态链接关系显然可以通过LCT实现。
然而,这个链接关系可能会形成环,而LCT显然是不支持环结构的。怎么办?
<1>无环,无环的话,从每个点沿着有向边出发,最终找到的节点,这个节点指向0即可
		注意,明确对应关系的话,问题会更好做,要知道——这个点就是根节点!
<2>有环,有环的话,其实我们需要使得一个节点的指向关系存储却不生效。
		想想看,这个节点,其实也只能是根节点。
得到之前的结论,问题便变得清晰一些了——
1. 我们只要生效所有链接关系,比如此时要链接(x, y),x是还没有生效链接关系的,但是发现find_root(y) == x,那便发现了环。
   于是我们在物理结构上,x依然是access()后能得到的根(之一),但同时保留了v[x],有v[x]不为0。即根的v[]不为0,也就对应着是存在了环
2. 我们过程中还要继续生效链关系,比如此时要链接(x, y)。但是——
	对于x,其之前可能也存在着链接的目标z
	如果x是根,(x,z)的链接关系可能未生效,我们直接相对于对x做崭新的链接即可
	如果(x,z)的链接关系已经生效,首先我们一定要断开(x,z)的链接关系,然后对于z所在的tree的root,如果其root和v[root]之间断边了,则修改v[root]
	然后的链接操作与之前无异,是傻瓜式的。
于是link这么写——
void link(int x, int y)
{
	int w = find_root(x);//先找到根节点
	if (v[x] && x != w)cut(x, v[x]);//有边且不是根节点,就删边
	v[x] = y;//标记
	if (y && x != find_root(y))splay(x), fa[x] = v[x];//根据是否有环决定是否加边,splay(x)而不是access(x)是因为x显然是根,其实都一样
	if (v[w] && x != w && w != find_root(v[w]))splay(w), fa[w] = v[w];//根据是否有环决定是否恢复边,splay(w)是因为w显然是根

	//注意,这里我们是有判断x != find_root(y)和 w != find_root(v[w]),左侧之所以不用find_root(x)和find_root(w),
	//是因为左侧的点必然是根,而如果x == w,则显然x因为指向了y,x就不再是根,即导致最后一句话出错,于是加了条件x != w
	//其实可以不加这些判定条件,而把x换成find_root(x),把w换成find_root(w)来解决问题。
}
cut这么写——(其实这里的cut不需要参数y)
void cut(int x, int y)
{
	//if (x == y || find_root(x) != find_root(y)) { puts("-1"); return; }
	access(x);
	ch[x][0] = fa[ch[x][0]] = 0;//rgt -> lft
}

HDU5333 LCT动态树 离线询问+树状数组(本题与HDU4677题意和做法完全相同,只是数据范围卡住了分块做法)
[题意]
给你一个n(1e5)点和m(2e5)边的无向图。
同时存在q(1e5)个询问,对于每个询问,有区间[L, R]
我们只连接两个端点都在[L, R]中的所有边,则该图会形成多少个连通块。
[分析]
显然,[1, L - 1] 与 [R + 1, n]中的点都没有任何边连接。
于是,答案其实是:(L - 1 + n - R) + [L, R]区间内起到实质效应的边数。
首先这道题询问众多,我们考虑离线化所有询问。
比如,我们按照右界从小到大的顺序,对所有边做排序,就可以只加入右界不超过R的所有边。
然而,这样子形成的图并不一定是树,可能形成了图,这使得我们无法动态维护splay。
于是,我们在加边的过程中也要动态维护其森林结构。
具体的做法是使用贪心,对于每次新加的边(不考虑自环和重边),如果加入该边会形成环,那么,
对于加边(x, y)之间的链,和该边共成的环,我们删掉环上的任意一条边,整个图的连通性都是一样的。
这里基于后效性最优的贪心原则,我们只要删掉该环上左端点最小的边,该边的用途是最小的。
于是,我们把边抽象为点,原始点的边权为极大,边点的权值为该边所对应的较小节点的编号,于是LCT的查询是树链上的最小节点编号。
因为右边界为R的询问也有很多,对应很多不同的L,我们用树状数组维护此时有从L ~ n的边加了多少条。
每多一条边便少一个连通块,由此更新答案。
void solve()
{
	v[ID = 0] = inf;
	for (int i = 1; i <= n; ++i) newnode(inf), bit.v[i] = 0;
	for (int i = 1; i <= m; ++i) 
	{ 
		scanf("%d%d", &edge[i].l, &edge[i].r); 
		if (edge[i].r < edge[i].l)swap(edge[i].l, edge[i].r);
	}
	for (int i = 1; i <= Q; ++i) 
	{ 
		scanf("%d%d", &q[i].l, &q[i].r); 
		q[i].id = i; 
	}
	sort(edge + 1, edge + m + 1);
	sort(q + 1, q + Q + 1);
	for (int i = 1, p = 1; i <= Q; ++i)
	{
		while (p <= m && edge[p].r <= q[i].r)
		{
			int x = edge[p].l;
			int y = edge[p++].r;
			int o = newnode(x);
			if (x == y || x == edge[p - 2].l && y == edge[p - 2].r)continue;
			if (find_root(x) == find_root(y))
			{
				getlink(x, y);
				int u = mp[y];
				if (v[u] >= x)continue;
				cut(u, edge[u - n].l);
				cut(u, edge[u - n].r);
				bit.modify(v[u], -1);
			}
			link(x, o);
			link(y, o);
			bit.modify(x, 1);
		}
		ans[q[i].id] = n - bit.check(q[i].l);
	}
	for (int i = 1; i <= Q; ++i)printf("%d\n", ans[i]);
}


2014-2015 ACM-ICPC(CERC 14) J LCT动态树 + 可持久化线段树 Pork barrel
[题意]
n(1000)个点
m(100000)条边
q(1e6)个询问
对于每个询问[L,R],问你,如果使用的边的边权在[L,R]范围内,那么——
我们能够得到的最小边权的极大生成森林的边权之和是多少,强制在线。
[分析]
如果可以离线化的话,我们直接把边按照权值从大到小做排序,也把询问按照其左界从大到小做排序.
然后枚举询问,询问的左界递减,我们加的边数也越多。
对于一条边,如果其加入成环了,我们会删掉其所在环上边权最大的一条边。
然后对于查询[L,R],如果有能够起到同样功效的大边,会被删掉,如果有没有能够起到相同功效的大边,我们也保留了适当的小边。
也就是说,在树状数组中动态维护边权,check(r)就是答案。
然而,这道题需要使得询问在线,于是,如果我们还想要使用离线的方法的话,就要记录下所有可能询问的答案。
该做法是使用可持久化线段树(或者可持久化树状数组),对于每一个左界我们都维护一棵线段树,最后查询就好啦——
void solve()
{
	scanf("%d%d", &n, &m);
	v[ID = 0] = -inf;
	for (int i = 1; i <= n; ++i) newnode(-inf);
	topval = 0; for (int i = 1; i <= m; ++i)
	{
		scanf("%d%d%d", &edge[i].x, &edge[i].y, &edge[i].v);
		rk[++topval] = edge[i].v;
	}
	sort(rk + 1, rk + topval + 1);
	topval = unique(rk + 1, rk + topval + 1) - rk - 1;
	sort(edge + 1, edge + m + 1);
	pst.sz = 0; pst.rt[topval + 1] = 0;
	for(int l = topval, p = 1; l >= 1; --l)
	{
		pst.rt[l] = pst.rt[l + 1];
		while (p <= m && edge[p].v == rk[l])
		{
			int x = edge[p].x;
			int y = edge[p].y;
			int o = newnode(edge[p++].v);
			if (find_root(x) == find_root(y))
			{
				getlink(x, y);
				int u = mp[y];
				if (v[u] <= v[o])continue;
				cut(u, edge[u - n].x);
				cut(u, edge[u - n].y);
				pst.addp(pst.rt[l], 1, topval, lower_bound(rk + 1, rk + topval + 1, v[u]) - rk, -v[u]);
			}
			pst.addp(pst.rt[l], 1, topval, l, v[o]);
			link(x, o);
			link(y, o);
		}
	}
	scanf("%d", &Q);
	int ans = 0;
	for (int i = 1; i <= Q; ++i)
	{
		int l, r; scanf("%d%d", &l, &r);
		l = lower_bound(rk + 1, rk + topval + 1, l - ans) - rk;
		r = upper_bound(rk + 1, rk + topval + 1, r - ans) - rk - 1;
		if (l > r)ans = 0;
		else ans = pst.check(pst.rt[l], 1, topval, l, r);
		printf("%d\n", ans);
	}
}


*/


你可能感兴趣的:(模板)