一类用 LCT 维护信息的题目

最新推荐文章于 2022-04-06 23:00:19 发布
最新推荐文章于 2022-04-06 23:00:19 发布
阅读量1.2k 收藏 2
点赞数 4
分类专栏： 算法解析 杂题瞎记 文章标签： LCT
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DT_Kang/article/details/86607565
版权

1

给定一棵n个点的树，点有正点权，支持修改点权，查询带权直径。

普通的 DP 需要维护最长链和次长链，带修改的话不容易动态维护。因此我们采用另一种方法：找两次最远点。

LCT 维护的是：对于一棵 splay 的某个点，维护它 LCT 子树的答案，也就是对应的这条链的链顶的子树内，从这条链的端点出发的最长链（可能有点绕，很多 LCT 维护信息都是这么维护的）。为了维护这个信息，我们还需要维护每个虚儿子出发向（原树）子树的最长链，为了支持 access 用一个堆维护这些最长链，用堆顶就可以 push_up。

/*
lmax:从链顶出发的最长链
rmax:从链尾出发的最长链
sum:splay子树点权和
s:虚儿子最长链的堆
*/
#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int N=100010;
struct node{
	ll w;int x;
}lmax[N],rmax[N],Max[N];
struct edge{
	int to,next;
}ed[N<<1];

multiset <node> s[N];
int fa[N],son[N][2],a[N],sz,head[N];
ll sum[N];

inline void add_edge(int from,int to)
{
	ed[++sz].to=to;
	ed[sz].next=head[from];
	head[from]=sz;
}

node operator + (node a,ll x)
{
	a.w+=x;
	return a;
}
bool operator < (node a,node b)
{
	if(a.w==b.w) return a.x<b.x;
	return a.w<b.w;
}
inline int read()
{
	char c=getchar();int x=0,flag=1;
	while(!isdigit(c)){if(c=='-') flag=-1;c=getchar();}
	while(isdigit(c)) x=x*10+c-'0',c=getchar();
	return x*flag;
}
void dfs(int u,int ff)
{
	for(int i=head[u];i;i=ed[i].next)
	{
		int v=ed[i].to;
		if(v==ff) continue;
		fa[v]=u;
		dfs(v,u);
		s[u].insert(lmax[v]);
	}
	lmax[u]=rmax[u]=*s[u].rbegin()+a[u];
	Max[u]=*s[u].rbegin();
}
bool nroot(int x)
{
	return son[fa[x]][0]==x||son[fa[x]][1]==x;
}
void push_up(int x)
{
	int ls=son[x][0],rs=son[x][1];
	lmax[x]=max(lmax[ls],max(lmax[rs],Max[x])+sum[ls]+a[x]);
	rmax[x]=max(rmax[rs],max(rmax[ls],Max[x])+sum[rs]+a[x]);
	sum[x]=sum[ls]+sum[rs]+a[x];
}
void rotate(int x)
{
	int y=fa[x],z=fa[y],kind=x==son[y][0];
	int tmp=nroot(y);
	son[y][!kind]=son[x][kind];
	fa[son[x][kind]]=y;
	son[x][kind]=y;
	fa[y]=x;
	fa[x]=z;
	if(tmp) 
	{
		if(y==son[z][0]) son[z][0]=x;
		else son[z][1]=x;
	}
	push_up(y);
}
void splay(int x)
{
	while(nroot(x))
	{
		int y=fa[x],z=fa[y];
		if(nroot(y)) 
		{
			if((x==son[y][0])^(y==son[z][0])) rotate(x);
			else rotate(y);
		}
		rotate(x);
	}
	push_up(x);
}
void access(int x)
{
	for(int y=0;x;x=fa[y=x])
	{
		splay(x);
		if(son[x][1]) s[x].insert(lmax[son[x][1]]);
		son[x][1]=y;
		if(y) s[x].erase(s[x].find(lmax[y]));
		Max[x]=*s[x].rbegin();
		push_up(x);
	}
}
int main()
{
	int n=read(),m=read();
	for(int i=1;i<=n;i++) a[i]=read(),s[i].insert((node){0,i});
	for(int i=1;i<n;i++) 
	{
		int u=read(),v=read();
		add_edge(u,v),add_edge(v,u);
	}
	dfs(1,0);
	while(m--)
	{
		int x=read(),y=read();
		access(x),splay(x);
		a[x]=y;
		push_up(x);
		x=lmax[x].x;
		access(x);
		splay(x);
		cout<<rmax[x].w<<'\n';
	}
	return 0;
}
/*by DT_Kang*/

2

我们的 CPU 遭到攻击
维护一个森林，边有边权，支持 Link，Cut，反转一个点的颜色（黑白），查询某个联通块的所有黑点到某个点的距离之和。

这个题同样的，我们 splay 上的点维护 LCT 子树到链头/尾的答案（因为要支持 makeroot）。为了维护答案，还有维护黑点数量，边权之和。对于每个点，还要维护虚子树的黑点之和，以及虚子树答案。

/*
size:LCT子树黑点数
sizei:虚子树黑点数
ansi:虚儿子的答案
ansl:到链顶答案
sum:splay子树边权和
*/
#include<bits/stdc++.h>
#define ll long long
using namespace std;
unordered_map <ll,int> mp;
int son[400010][2],size[400010],sizei[400010],col[400010],val[400010],tot,fa[400010],tmp[400010],rev[400010];
ll ansl[400010],ansr[400010],ansi[400010],sum[400010];
inline int read()
{
	char c=getchar();int x=0,flag=1;
	while(!isdigit(c)){if(c=='-') flag=-1;c=getchar();}
	while(isdigit(c)) x=x*10+c-'0',c=getchar();
	return x*flag;
}
bool notroot(int x)
{
	return (son[fa[x]][0]==x)||(son[fa[x]][1]==x);
}
void reverse(int x)
{
	rev[x]^=1;
	swap(son[x][0],son[x][1]);
	swap(ansl[x],ansr[x]);
}
void push_up(int x)
{
	int ls=son[x][0],rs=son[x][1];
	sum[x]=sum[ls]+sum[rs]+val[x];
	size[x]=size[ls]+size[rs]+col[x]+sizei[x];
	ansl[x]=ansl[ls]+ansl[rs]+(sum[ls]+val[x])*(size[rs]+sizei[x]+col[x])+ansi[x];
	ansr[x]=ansr[rs]+ansr[ls]+(sum[rs]+val[x])*(size[ls]+sizei[x]+col[x])+ansi[x];
}
void push_down(int x)
{
	if(rev[x])
	{
		if(son[x][0]) reverse(son[x][0]);
		if(son[x][1]) reverse(son[x][1]);
		rev[x]=0;
	}
}
void rotate(int x)
{
	int y=fa[x],z=fa[y],kind= x==son[y][0];
	int tmp=notroot(y);
	son[y][!kind]=son[x][kind];
	fa[son[x][kind]]=y;
	fa[y]=x;
	son[x][kind]=y;
	fa[x]=z;
	if(tmp)
	{
		if(y==son[z][0]) son[z][0]=x;
		else son[z][1]=x;
	}
	push_up(y);
	push_up(x);
}
void splay(int x)
{
	int y=x,p=0;
	while(notroot(y)) tmp[++p]=y,y=fa[y];
	tmp[++p]=y;
	while(p--) push_down(tmp[p+1]);
	while(notroot(x))
	{
		int y=fa[x],z=fa[y];
		if(notroot(y))
		{
			if((x==son[y][0])^(y==son[z][0])) rotate(x);
			else rotate(y);
		}
		rotate(x);
	}
}
void access(int x)
{
	for(int y=0;x;x=fa[y=x])
	{
		splay(x);
		int tmp=son[x][1];
		sizei[x]+=size[tmp];
		ansi[x]+=ansl[tmp];
		son[x][1]=y;
		sizei[x]-=size[y];
		ansi[x]-=ansl[y];
		push_up(x);
	}
}
void makeroot(int x)
{
	access(x),splay(x);
	reverse(x);
}
void Link(int x,int y)
{
	makeroot(x),makeroot(y);
	fa[x]=y,sizei[y]+=size[x],ansi[y]+=ansl[x];
	push_up(y);
}
void Cut(int x,int y)
{
	makeroot(x),access(y),splay(y);
	son[y][0]=fa[x]=0;
	push_up(y);
}
void add_edge(int x,int y,int w)
{
	tot++,val[tot]=w;
	Link(x,tot),Link(tot,y);
	mp[1000000ll*x+y]=mp[1000000ll*y+x]=tot;
}
int main()
{
	int n=read(),m=read(),k=read();
	tot=n;
	for(int i=1;i<=m;i++)
	{
		int u=read(),v=read(),w=read();
		add_edge(u,v,w);
	}
	while(k--)
	{
		char s[5];
		scanf("%s",s);
		char c=s[0];
		int x,y,w,tmp;
		if(c=='L') x=read(),y=read(),w=read(),add_edge(x,y,w);
		else if(c=='C') x=read(),y=read(),tmp=mp[1000000ll*x+y],Cut(x,tmp),Cut(tmp,y);
		else if(c=='F') x=read(),access(x),splay(x),col[x]^=1,push_up(x);
		else //if(c=='Q') 
		x=read(),makeroot(x),splay(x),cout<<ansl[x]<<'\n';
	}
	return 0;
}
/*by DT_Kang*/

3

Qtree7
维护三种操作：修改点的颜色（黑白），修改点的权值，查询 x 所在同色联通块的最大权值。

维护同色联通块的小技巧：我们把点的颜色放在它到父亲这条边上，同色边放在一棵 LCT 里。容易发现一个联通块只有根节点颜色不同。注意特判整棵树的根。

这个 LCT 是不需要换根的，注意 Link，Cut 的写法。

#include<bits/stdc++.h>
#define ll long long
#define pb push_back
#define fir first
#define sec second
#define ld long double
using namespace std;
const int N=200020,inf=1e9;
typedef pair <int,int> P;
struct edge {
	int to,next;
}ed[N<<2];
int head[N],col[N],w[N],sz;
void add_edge(int from,int to)
{
	ed[++sz].to=to;
	ed[sz].next=head[from];
	head[from]=sz;
}
int read()
{
	int x=0;char c=getchar(),flag='+';
	while(!isdigit(c)) flag=c,c=getchar();
	while(isdigit(c)) x=x*10+c-'0',c=getchar();
	return flag=='-'?-x:x;
}
struct Heap 
{
	priority_queue <int> q1,q2;
	void push(int x) {q1.push(x);}
	void erase(int x) {q2.push(x);}
	int top() {while(q2.size()&&q1.top()==q2.top()) q2.pop(),q1.pop();return q1.top();}
};
struct LCT 
{
	int son[N][2],fa[N],mx[N];
	Heap si[N];
	bool nroot(int x) {return son[fa[x]][0]==x||son[fa[x]][1]==x;}
	void up(int x) {mx[x]=max(max(mx[son[x][0]],mx[son[x][1]]),max(w[x],si[x].top()));}
	void rotate(int x)
	{
		int y=fa[x],z=fa[y],kind=x==son[y][0],tmp=nroot(y);
		son[y][!kind]=son[x][kind];
		fa[son[x][kind]]=y;
		son[x][kind]=y;
		fa[y]=x,fa[x]=z;
		if(tmp)
		{
			if(y==son[z][0]) son[z][0]=x;
			else son[z][1]=x;
		}
		up(y),up(x);
	}
	void splay(int x)
	{
		while(nroot(x))
		{
			int y=fa[x],z=fa[y];
			if(nroot(y)) 
			{
				if(x==son[y][0]^y==son[z][0]) rotate(x);
				else rotate(y);
			}
			rotate(x);
		}
	}
	void access(int x)
	{
		for(int y=0;x;x=fa[y=x])
		{
			splay(x);
			if(son[x][1]) si[x].push(mx[son[x][1]]);
			if(y) si[x].erase(mx[y]);
			son[x][1]=y,up(x);
		}
	}
	void Cut(int x,int y)
	{
		if(!y) return;
		access(x),splay(x);
		son[x][0]=fa[son[x][0]]=0;
		up(x);
	}
	void Link(int x,int y) 
	{
		if(!y) return;
		access(x),splay(x);
		access(y),splay(y);
		fa[x]=y;
		si[y].push(mx[x]);
		up(y);
	}
	int find(int x)
	{
		access(x),splay(x);
		int now=x;
		while(son[now][0]) now=son[now][0];
		return now;
	}
};
LCT T[2];
int fa[N];
void dfs(int u,int ff)
{
	for(int i=head[u];i;i=ed[i].next)
	{
		int v=ed[i].to;
		if(v==ff) continue;
		T[col[v]].Link(v,u);
		fa[v]=u;
		dfs(v,u);
	}
}
int main()
{
	int n=read();
	for(int i=1;i<n;i++)
	{
		int u=read(),v=read();
		add_edge(u,v),add_edge(v,u);
	}
	T[0].mx[0]=T[1].mx[0]=-inf;
	for(int i=1;i<=n;i++) col[i]=read(),T[0].si[i].push(-inf),T[1].si[i].push(-inf),T[0].up(i),T[1].up(i);
	for(int i=1;i<=n;i++) w[i]=read();
	
	dfs(1,0);
	int m=read();

	for(int i=1;i<=m;i++)
	{
		int opt=read(),x=read(),c=col[x];
		if(opt==0) 
		{
			int tmp=T[c].find(x);
			T[c].access(x);
			T[c].splay(tmp);
			if(c==col[tmp]) cout<<T[c].mx[tmp]<<'\n';
			else cout<<T[c].mx[T[c].son[tmp][1]]<<'\n';
		}
		else if(opt==1)
		{
			T[c].Cut(x,fa[x]);
			col[x]^=1,c^=1;
			T[c].Link(x,fa[x]);
		}
		else 
		{
			int val=read();
			T[c].access(x),T[c].splay(x);
			w[x]=val;
			T[c].up(x);
		}
	}
	return 0;
}
/*by DT_Kang*/
Hellsegamosken
关注
  • 4
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LCT模板 LCT题型大荟萃
snowy_smile的博客
01-21 1087
以HDU4010为例，写了LCT相关的一些题目的做法 #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace std; void fre() { freopen("c://test//in
[bzoj2959]长跑——lct动态维护边双信息
ylsoi的博客
08-11 338
题目大意： 某校开展了同学们喜闻乐见的阳光长跑活动。为了能“为祖国健康工作五十年”，同学们纷纷离开寝室，离开教室，离开实验室，到操场参加3000米长跑运动。一时间操场上熙熙攘攘，摩肩接踵，盛况空前。 　　为了让同学们更好地监督自己，学校推行了刷卡机制。 　　学校中有n个地点，用1到n的整数表示，每个地点设有若干个刷卡机。 　　有以下三类事件： 　　1、修建了一条连接A地点和B地点的跑道。...
NOIP 2018 保卫王国 （动态 DP）（LCT）
FSYo 的博客
11-13 276
传送门 跟动态 DP 的模板差不多 考虑朴素的树形 dpdpdp fu,0=∑vfv,1f_{u,0}=\sum_{v}f_{v,1}fu,0​=v∑​fv,1​ fu,1=val[u]+∑vmin(fv,0,fv,1)f_{u,1}=val[u]+\sum_{v}min(f_{v,0},f_{v,1})fu,1​=val[u]+v∑​min(fv,0​,fv,1​) 令 gu,0/1g_{u,0...
HDU 5293 TREE CHAIN PROBLEM LCT+树形DP
九野的博客
07-22 1427
题解链接 代码链接 链接 Tree chain problem Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 35    Accepted Submission(s): 8 Problem Descr
2018.12.12【BZOJ5192】【洛谷P4271】New Barns（LCT维护直径）
zxyoi_dreamer的博客（不定期诈尸）
12-12 427
BZOJ传送门 洛谷传送门 解析： 许久没有写LCT，手都有点生了。 思路： 这道题是显然的需要维护直径的，因为有结论，树上距离一个点的最远点一定是某个直径的端点。证明很显然，就不证了。 那么怎么维护动态的直径呢？ 我们可以用LCT维护一个森林，对于每棵树记录直径的两个端点，加入一个新点的时候更新，我们有如下结论：新的直径与原来直径至少有一个端点重合。 那么LCT乱搞一波就做完了。 代码： #...
lct.zip_LCT
09-19
然而，根据提供的描述，我们并没有直接获得关于"LCT"的具体技术细节，描述中的“2222我而无法说服 去取钱完全 完全”似乎与技术主题不直接相关，可能是一条错误的信息或者编码错误。 【标签】"lct" 仅提供了与"LCT...
lct_LCT_
09-29
标题中的“lct_LCT_”很可能代表“Link-Cut Tree”，这是一项在计算机科学领域，特别是算法设计中广泛使用的数据结构。Link-Cut Tree（链接切割树）是一种自顶向下的动态树数据结构，主要用于解决与树相关的操作，如...
lct.zip_lct文件
09-24
压缩包中的“流程图”文件，可能是一个图像文件，如PNG、JPEG或SVG格式，展示了使用“lct”库时的步骤或者工作流程。流程图对于理解库的使用方法非常有用，它通常会通过图形化的方式表示出操作顺序、条件判断和数据...
LCT的定义和应用场景
最新发布
07-26
lct
动态树LCT BySemiWaker
03-05
动态树LCT
LCT模板题2 最长链
Fire Dancer
03-07 657
树是任意两点间仅有一条路径的联通图，树上的一条链定义为两个点之间的路径。在本题中定义一条链的长度为链上所有点的权值和。现有一棵带点权树，要对它进行一些操作，请你在第一次操作前和每一次操作后输出这棵树的最长链。 这题非常不错的虚边维护儿子信息的LCT,并且,利用LCT splay 维护的是链的性质,可以动态的利用最大子段和的方式进行合并,主要思想就是维护以x节点为根的子树所表示的链的从头开始的最大...
【Comet OJ - Contest #8 F 黄金体验】【lct】
beginend
08-12 260
题意 有一棵nnn个节点的树，每个点有一个初始权值wiw_iwi​，要求支持两种操作： 1、使xxx的点权增加yyy 2、给出kkk，选定kkk个点使得包含这kkk个点的最小联通子图点权和最大，你只需要输出这个最大值。 n,q≤105n,q\le10^5n,q≤105 分析 若k=2k=2k=2，显然选的是带权最长链。 可以发现kkk每增加111，新的答案显然是在原来最优方案的基础上，新加入一个叶...
[USACO18FEB]New Barns P lct维护树的直径
weixin_43824564的博客
06-04 476
树的直径，通俗点讲就是树中两个距离最远的点。 在做此题之前我们需要证明一个结论，那就是一棵树里面和某个点x距离最远的点一定是树的直径的端点。 也就是说如果路径(u,v)是树的直径，那么距离x最远的点要么是u,要么是v 我们来证明一下： 1.x在路径(u,v)上 假设 y是距离x最远的点 那么 则 因为x在u,v上 所以 得到 与(u,v)是树的直径的定义相矛盾 2.x不在路径(u,v)上 同样假设y是距离x最远的点 且y和路径(u,v)的最近点为b 那么有...
[USACO18FEB]New Barns P,洛谷P4271,LCT维护直径
Deep_Kevin的娱乐空间
09-01 263
正题 比较蠢,没想到. 其实给两个联通块连一条边也是可以的,就是将两个联通块的直径端点两两求一次距离,求距离可以用LCT来维护点权,然后split一下-1就是距离了.再用一个带权并查集来维护两个直径端点就可以了. #include<bits/stdc++.h> using namespace std; const int N=100010; struct node{ int son[2],fa,tot; bool swp; }s[N]; int a[N],b...
LCT维护子树信息（子树信息LCT） LCT维护边权（边权LCT） 知识点讲解
neither_nor
10-31 9330
扯淡（前言） 众所周知LCT可以支持关于点权的链修改，换根，LINK，CUT和查询链信息操作，但是总有那么些神犇（毒瘤）出题人会让你在支持链修改，换根，LINK和CUT操作的情况下去支持子树查询，或者维护关于边权的链修改，换根，LINK，CUT和链查询。网上似乎讲解这两种LCT写法的blog比较少或者不怎么能搜到？总之我来写一发 （LCT基础知识回顾） 为了方便说话先说一下下面可能出现的
Lct系列小结
袋鼠与蒟蒻
07-02 1045
  这个东西欠了很久了(博客也停了很久了) 这篇博文不负责讲解Lct的基础知识（太麻烦）所以有需要的同学可以看这里 PART 1  我们首先给一个模板 struct Splay{     int F,s[2],rev;     int val,sum;     inline void NewNode(int fa,int x){         F=fa; s[0]=s[1]=rev=...
20181231省选模拟赛：树 LCT维护树直径
maxtir的博客
01-02 1403
省选模拟赛：树 分析 考场上想出来了一个被卡常了的点分治的O(nlog2)O(nlog^2)O(nlog2)的做法，T到起飞。。 有一种假装好些好调的LCTLCTLCT做法。 因为LCTLCTLCT的辅助树内维护的是一条链，而我们维护的是到这条实链上的最浅和最深的节点到当前子树内的最远距离。 考虑采用rmxrmxrmx和lmxlmxlmx分别表示最深和最浅，mxsmxsmxs表示最长链。 既然...
bzoj1912——树的最长链
stevensonson的博客
03-06 678
Description Input 第一行包含两个整数 n, K(1 ≤ K ≤ 2)。接下来 n – 1行，每行两个整数 a, b， 表示村庄a与b之间有一条道路(1 ≤ a, b ≤ n)。 Output 输出一个整数，表示新建了K 条道路后能达到的最小巡逻距离。 Sample Input 8 1 1 2 3 1 3 4 5 3 7 5 8 5 5 ...
CF1192B Dynamic Diameter（LCT）
BUG_Creater_jie的博客
04-06 282
LCT维护直径
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值