关于树链剖分

最新推荐文章于 2024-08-20 17:50:28 发布
最新推荐文章于 2024-08-20 17:50:28 发布
阅读量122 收藏 1
点赞数
分类专栏： luogu 学校集训 日常 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SSL_hhw/article/details/123014148
版权
日常 同时被 3 个专栏收录
28 篇文章 2 订阅
订阅专栏
学校集训
13 篇文章 1 订阅
订阅专栏
luogu
5 篇文章 0 订阅
订阅专栏
本文详细介绍了树链剖分的概念和实现，通过构建树并统计子树大小确定重儿子，进而进行重轻链的划分。使用线段树维护重链，实现快速查询和修改操作，达到logn的时间复杂度。文章通过实例展示了如何进行链的映射、线段树的构造以及查询、修改操作，同时讲解了lca在更新过程中的应用，为解决树上动态查询问题提供了一种高效方法。
摘要由CSDN通过智能技术生成

树链剖分

模板题

顾名思义，即是把树的形态用线性链表表示出来。
那么首先就是要造个树。

ll siz[N],dep[N],son[N],fa[N];//son是以x为祖先的重儿子坐标 
void build_tree(int now)
{
	siz[now]=1;//初始化树的大小
	for(int i=he[now];i;i=nxt[i])
	{
		int tar=to[i];
		if(tar==fa[now]) continue;
		fa[tar]=now,dep[tar]=dep[now]+1;
		build_tree(tar);
		siz[now]+=siz[tar];
		if(siz[tar]>siz[son[now]]) son[now]=tar;
	 } 
}

那么首先在这里就是除了正常造树，还要顺便统计一下以每个节点为根的子树大小，以方便后面重儿子，轻儿子的确定，那么什么是重儿子呢，比如我现在有个2号节点，那么我有4，5两个儿子节点，那么以4，5为节点的分别的子树大小为3，2那么因为以4的节点子树较大，那么我们说4是3的重儿子，连着一条重边，代码中的son数组就是记录以当前节点为父节点的重儿子的id。

那么接下来就是要用数组通过刚才对重儿子的标记来进行分链的操作。

ll past[N]/*关于dfs序对点的坐标的一个映射*/,dfs[N]/*所在点的dfs序*/,top[N],tot,ctr[N]; 
void remark(int poi,int tp)//所在点以及当前点所在重链的顶端 
{
    top[poi]=tp;
 	dfs[poi]=++tot;
 	past[tot]=poi;
 	if(son[poi]) remark(son[poi],tp);//优先往重链那里走
	for(int i=he[poi];i;i=nxt[i])
	{
		int tar=to[i];
		if(tar!=son[poi]&&tar!=fa[poi]) remark(tar,tar);//轻链
	 } 
 	ctr[poi]=tot;//子树的范围是dfs[poi]~ctr[poi]，记录的是以poi为根的子树的最大dfs序 
}

这里的那个ctr数组记录的是每个子树的最大dfs续，其实也就是每个链条划分的长度。

那么，为了方便查询这些链条我们需要用一些其他的数据结构来维护这些链条。这里小编用的是线段树。

int len;//对于线段树的dfs序记录， 
struct node
{
	int l,r,idl,idr/*关于len的映射 左右儿子的编号*/;
	ll c,late;//c记录重链权值 
}tree[N];
void line_tree(int x,int y)
{
	++len;
	tree[len].l=x;
	tree[len].r=y;
	tree[len].late=0;
	if(x==y)
	{
	  tree[len].idl=tree[len].idr=-1;
	  tree[len].c=val[past[x]];//映射回原来主树的编号	
	}		
	else
	{
		int now=len,mid=(x+y)>>1;
		tree[now].idl=len+1,line_tree(x,mid);
		tree[now].idr=len+1,line_tree(mid+1,y);
		tree[now].c=tree[tree[now].idl].c+tree[tree[now].idr].c;
	} 
}
void sent(int x)//线段树的下传操作，late部分为懒标记 
{	
	if(tree[x].late)
	{
		tree[x].c+=tree[x].late*(tree[x].r-tree[x].l+1);
		int q=tree[x].idl,p=tree[x].idr;
		if(q!=-1) tree[q].late+=tree[x].late,tree[p].late+=tree[x].late;//如果以此为节点后还有儿子那么进行下传操作 
		tree[x].late=0;
	}	
}

这里我们用到结构体来当树单元比较方便记录，这里实际上是通过树上每一个链条的范围来进行映射，这样子，通过重轻链的划分， 每次查询可以做到logn的时间复杂度。

那么实际上到这里这里就可以实现查询了，那么怎么去改变树里面的权值呢。

void change(int now,int x,int y,int z)
{
	if(tree[now].l==x&&tree[now].r==y)
	{ 
		tree[now].late+=z;
		sent(now);
		return; 
	}	
	sent(now);
	int q=tree[now].idl,p=tree[now].idr;
	int mid=(tree[now].l+tree[now].r)>>1;
	if(y<=mid) change(q,x,y,z);
	else if(x>mid) change(p,x,y,z);
	else change(q,x,mid,z),change(p,mid+1,y,z);
	tree[now].c+=(y-x+1)*z;
}

这里实际上就是对链的长度进行修改便于权值下传，并且修改区域里面的和值。

接下来我们就要进行查询。

void lca(int x,int y,int z)
{
	while(top[x]!=top[y])//两个点不在一条重链上 
	{
		if(dep[top[x]]>dep[top[y]]) swap(x,y);//深度深的默认为y优先跳重链顶点深的
		change(1,dfs[top[y]],dfs[y],z);//从第一层开始找起 
		y=fa[top[y]]; 
	}	
	if(dep[x]>dep[y]) swap(x,y);//交换 
	change(1,dfs[x],dfs[y],z);//当在同一条重链再更新一次 
}

这里用到lca,这里因为给的是原树的id那么我们就要用映射的线段树的id，所以要用dfs来从线段树第一层开始找起。

void sum(int x,int y)//统计x~y的权值和
{
	ll ans=0;
	while(top[x]!=top[y])
	{
		if(dep[top[x]]>dep[top[y]]) swap(x,y);
		ans=(ans+get_sum(1,dfs[top[y]],dfs[y])%p)%p;
		y=fa[top[y]];	
	}
	if(dep[x]>dep[y]) swap(x,y);
	ans+=get_sum(1,dfs[x],dfs[y]);//已经在同一条重链上 
	ks(ans%p),putchar('\n');	 
}

完整代码

#include<cstdio>
#include<iostream>
using namespace std;
typedef long long ll;
const ll N=2e5+11;
ll n,m,r,p;
int opt,x,y,z;
ll cnt,val[N],to[N],he[N],nxt[N];
ll qread()
{
	ll xx=0;
	char c=getchar();
	while(c<'0'||c>'9') c=getchar();
	while(c>='0'&&c<='9') 
	{
		xx=(xx<<1)+(xx<<3)+c-'0';
		c=getchar();	
	}	
	return xx;
}
void ks(ll num)
{
    if(num>9) ks(num/10ll);
	putchar(num%10+'0');	
}
void add(int u,int v)
{
	++cnt;
	nxt[cnt]=he[u];
	he[u]=cnt;
	to[cnt]=v;
}
ll siz[N],dep[N],son[N],fa[N];//son是以x为祖先的重儿子坐标 
void build_tree(int now)
{
	siz[now]=1;//初始化树的大小
	for(int i=he[now];i;i=nxt[i])
	{
		int tar=to[i];
		if(tar==fa[now]) continue;
		fa[tar]=now,dep[tar]=dep[now]+1;
		build_tree(tar);
		siz[now]+=siz[tar];
		if(siz[tar]>siz[son[now]]) son[now]=tar;
	 } 
}
ll past[N]/*关于dfs序对点的坐标的一个映射*/,dfs[N]/*所在点的dfs序*/,top[N],tot,ctr[N]; 
void remark(int poi,int tp)//所在点以及当前点所在重链的顶端 
{
    top[poi]=tp;
 	dfs[poi]=++tot;
 	past[tot]=poi;
 	if(son[poi]) remark(son[poi],tp);//优先往重链那里走
	for(int i=he[poi];i;i=nxt[i])
	{
		int tar=to[i];
		if(tar!=son[poi]&&tar!=fa[poi]) remark(tar,tar);//轻链
	 } 
 	ctr[poi]=tot;//子树的范围是dfs[poi]~ctr[poi]，记录的是以poi为根的子树的最大dfs序 
}
int len;//对于线段树的dfs序记录， 
struct node
{
	int l,r,idl,idr/*关于len的映射 左右儿子的编号*/;
	ll c,late;//c记录重链权值 
}tree[N];
void line_tree(int x,int y)
{
	++len;
	tree[len].l=x;
	tree[len].r=y;
	tree[len].late=0;
	if(x==y)
	{
	  tree[len].idl=tree[len].idr=-1;
	  tree[len].c=val[past[x]];//映射回原来主树的编号	
	}		
	else
	{
		int now=len,mid=(x+y)>>1;
		tree[now].idl=len+1,line_tree(x,mid);
		tree[now].idr=len+1,line_tree(mid+1,y);
		tree[now].c=tree[tree[now].idl].c+tree[tree[now].idr].c;
	} 
}
void sent(int x)//线段树的下传操作，late部分为懒标记 
{	
	if(tree[x].late)
	{
		tree[x].c+=tree[x].late*(tree[x].r-tree[x].l+1);
		int q=tree[x].idl,p=tree[x].idr;
		if(q!=-1) tree[q].late+=tree[x].late,tree[p].late+=tree[x].late;//如果以此为节点后还有儿子那么进行下传操作 
		tree[x].late=0;
	}	
} 
void change(int now,int x,int y,int z)
{
	if(tree[now].l==x&&tree[now].r==y)
	{ 
		tree[now].late+=z;
		sent(now);
		return; 
	}	
	sent(now);
	int q=tree[now].idl,p=tree[now].idr;
	int mid=tree[now].l+tree[now].r>>1;
	if(y<=mid) change(q,x,y,z);
	else if(x>mid) change(p,x,y,z);
	else change(q,x,mid,z),change(p,mid+1,y,z);
	tree[now].c+=(y-x+1)*z;
} 
ll get_sum(int now,int x,int y)
{
	sent(now);//访问时先进行下传操作，不然可能会导致数据损失
	if(tree[now].l==x&&tree[now].r==y) return tree[now].c;
	int q=tree[now].idl,p=tree[now].idr;
	int mid=(tree[now].l+tree[now].r)>>1;
	if(y<=mid) return get_sum(q,x,y);
	else if(x>mid) return get_sum(p,x,y);
	else return get_sum(q,x,mid)+get_sum(p,mid+1,y);
}
void lca(int x,int y,int z)
{
	while(top[x]!=top[y])//两个点不在一条重链上 
	{
		if(dep[top[x]]>dep[top[y]]) swap(x,y);//深度深的默认为y优先跳重链顶点深的
		change(1,dfs[top[y]],dfs[y],z);//从第一层开始找起 
		y=fa[top[y]]; 
	}	
	if(dep[x]>dep[y]) swap(x,y);//交换 
	change(1,dfs[x],dfs[y],z);//当在同一条重链再更新一次 
} 
void sum(int x,int y)//统计x~y的权值和
{
	ll ans=0;
	while(top[x]!=top[y])
	{
		if(dep[top[x]]>dep[top[y]]) swap(x,y);
		ans=(ans+get_sum(1,dfs[top[y]],dfs[y])%p)%p;
		y=fa[top[y]];	
	}
	if(dep[x]>dep[y]) swap(x,y);
	ans+=get_sum(1,dfs[x],dfs[y]);//已经在同一条重链上 
	ks(ans%p),putchar('\n');	 
} 
void get_sum_sontree(int x)
{
	ks(get_sum(1,dfs[x],ctr[x])%p),putchar('\n'); 
}
void change_sontree(int x,int y)
{
	change(1,dfs[x],ctr[x],y);
}
int main()
{
	n=qread(),m=qread(),r=qread(),p=qread();
	for(int i=1;i<=n;++i) val[i]=qread();
	for(int i=1,x,y;i<=n-1;++i) x=qread(),y=qread(),add(x,y),add(y,x);
    build_tree(r);//建主树 
    remark(r,r);//记录重链 
    line_tree(1,tot);//用线段树维护重链 
	while(m--)
	{
		opt=qread();
		if(opt==1)
		{
			x=qread(),y=qread(),z=qread();
			lca(x,y,z);	
		}
		else if(opt==2)
		{
			x=qread(),y=qread();
			sum(x,y);
		}
		else if(opt==3)
		{
			x=qread(),z=qread();
			change_sontree(x,z);
		}
		else
		{
			x=qread();
			get_sum_sontree(x);
		}
	}
	return 0;
}
laruat
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
树链剖分详解
算法小猪的博客
08-13 1318
目录一、树链剖分相关概念1.为啥要剖分2.轻边和重边3.轻重边路径剖分的性质二、树链剖分的实现1.重链剖分 一、树链剖分相关概念 1.为啥要剖分 1.可以维护树路径上的信息(维护) 2.将一棵树划分成若干条链，用数据结构去维护每条链，复杂度为O(logN)O(logN)O(logN)。(复杂度低) 2.轻边和重边 将树中的边分为：轻边和重(zhong)边 定义size(x)size(x)size(x)为以xxx为根的子树的节点个数。 令vvv为xxx的儿子节点中sizesizesize值最大的节点，那么边(
树链剖分学习笔记
八声甘州
07-20 262
总是有出题人喜欢把序列上用线段树解决的题目出到树上，让选手强行写个树链剖分或树分治或某种动态树数据结构。 这种行为已经很无趣了。 所以我们想让大家知道，不光可以放在静态树上，动态仙人掌也是可以的。 开个头就跑 ...
树链剖分总结
ZhuRanCheng的博客
05-22 615
树链剖分总结
树链剖分（重链剖分）
m0_73666576的博客
03-24 1928
本文主要针对于还没有学习过这个算法的新手同学
树链剖分 模板小记
绫
07-21 115
树链剖分 模板小记树链剖分~模板小记树链剖分 模板小记 Q.Q.Q. 树链剖分的背景？ A.A.A. 连通且无环的树 Q.Q.Q. 树链剖分的作用？ A.A.A. 大幅增加码量 （ A.A.A. 将一棵树变成几条链 树形变成线形 减少处理难度 Q.Q.Q. 树链剖分能处理哪些问题？ A1.A_1.A1​. 修改的有： 将xxx节点+ or×val+~or\times val+ or×val 将xxx到yyy这条路径上所有节点+ or×val+~or\t
树链剖分
orz
07-07 88
模板 例题 #include <bits/stdc++.h> #define int long long #define ld lld #define _ 500005 #define ls(a) a << 1 #define rs(a) a << 1 | 1 using namespace std; int n, m, r, p; int op, x, y, z; int a[_], b[_]; int head[_], to[_], nxt[_], tot; int
191028-树链剖分
Daniel__d的博客
10-31 201
191028-树链剖分 定义 指一种对树进行划分的算法，它先通过轻重边剖分将树分为多条链，保证每个点属于且只属于一条链，然后再通过数据结构（树状数组、BST、SPLAY、线段树等）来维护每一条链。 那么什么是轻重边呢？ 很简单，来看下面一张图： 在轻重链剖分中，每个非叶节点有且仅有一个重儿子，其余子节点为轻儿子。轻重儿子划分的依据是子树大小，对于每个非叶节点， 其子树size最大的子节点成为...
洛谷 P3384 树链剖分(详解)
riba2534的博客
07-12 3956
题目描述 如题，已知一棵包含N个结点的树（连通且无环），每个节点上包含一个数值，需要支持以下操作： 操作1： 格式： 1 x y z 表示将树从x到y结点最短路径上所有节点的值都加上z 操作2： 格式： 2 x y 表示求树从x到y结点最短路径上所有节点的值之和 操作3： 格式： 3 x z 表示将以x为根节点的子树内所有节点值都加上z 操作4： 格...
树链剖分模板题
qq_44335608的博客
10-03 170
树链剖分的学习，我是从树链剖分-1和树链剖分-2来学会的。 模板题 简单讲一下树链剖分吧，就是它首先第一遍dfs1,就将f[i] ,dep[i] ,sz[i] ,son[i]都预处理好，它们分别代表节点i的父节点，深度，子节点的数量，重节点;第二遍dfs2，就将id[i]，rk[i]，top[i]，分别代表节点i的dfs序，dfs序为i的节点，节点i所在链的顶端节点。如果你有lca和线段树的知识，...
NOIP 树链剖分 NOIP 树链剖分
10-30
### NOIP 树链剖分知识点详解 #### 一、树链剖分的相关概念 **剖分目的**：树链剖分的主要目的是为了更高效地处理树状结构上的路径信息维护问题，例如路径上的权值更新或查询等操作。通过树链剖分，可以将这些操作...
树链剖分算法.pptx
09-03
树链剖分，计算机术语，指一种对树进行划分的算法，它先通过轻重边剖分将树分为多条链，保证每个点属于且只属于一条链，然后再通过数据结构（树状数组、BST、SPLAY、线段树等）来维护每一条链
NOIP树链剖分习题讲解报告
11-01
此题同样是关于树链剖分的应用，但涉及的操作更为复杂。除了基本的树链剖分外，还需要额外考虑如何高效地更新节点值以及求解子树的和。具体的解决方案包括： 1. **预处理阶段：** - 计算每个节点的深度、子树大小...
排序（归并排序，非比较排序）
最新发布
qq_63074244的博客
08-20 547
稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的 相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，⽽在排序后的序列中，r[i]仍在r[j]之 前，则称这种排序算法是稳定的；否则称为不稳定的。数据结构结构初阶的排序基本上总结完毕了，这里我学了冒泡，插入，选择，快排，希尔，堆，归并，计数排序，这几种排序在时间复杂度，空间复杂度以及稳定性上各有各的优点。下面我们用一张图进行总结。
代码随想录算法训练营第十七天（二叉树 五）
b1ankwall的博客
08-16 764
参加代码随想录第43期算法训练营day17|654.最大二叉树，617.合并二叉树，700.二叉搜索树中的搜索，98.验证二叉搜索树
【Python】生成二维迷宫的算法
HarryXYC的博客
08-16 317
基于Pygame和PIL的迷宫生成器
Leetcode 219. 存在重复元素 II
铁马冰河入梦来
08-20 195
哈希表解决存在重复元素二问题
NOIP树链剖分详解与实现
"NOIP树链剖分是用于优化树形结构数据的处理效率的一种算法，常用于解决涉及树路径信息维护的问题。该算法的主要目标是将一棵树划分为若干条链，每条链的数据结构可以高效地进行操作，使得在树上进行查询或更新操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值