树链剖分学习笔记

于 2024-08-19 11:19:25 发布
阅读量690 收藏 8
点赞数 18
文章标签： 学习 笔记 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mikeshizi1234/article/details/141220636
版权

前言

树链剖分这个东西呢，简而言之就是把一些树上的操作转换成线性的问题。那看起来平平无奇的树链剖分，为什么很多人就是喜欢使用他呢，那想必肯定是有原因的，我们先卖个关子，先看一下树链剖分怎么写，原理是什么。

前置芝士

  • 线段树
  • 树形dp
  • dfs序
    如果不会可以看往期的学习笔记

算法详解

树链剖分的话我们就讲个一道模版题，毕竟也是一种方法，可以选择性使用。

洛谷模板 P3384

如题，已知一棵包含 N N N 个结点的树（连通且无环），每个节点上包含一个数值，需要支持以下操作：

  • 1 x y z，表示将树从 x x x 到 y y y 结点最短路径上所有节点的值都加上 z z z。

  • 2 x y，表示求树从 x x x 到 y y y 结点最短路径上所有节点的值之和。

  • 3 x z，表示将以 x x x 为根节点的子树内所有节点值都加上 z z z。

  • 4 x 表示求以 x x x 为根节点的子树内所有节点值之和

概念简介

首先，因为后面在讲解的时候会涉及到一些名词，我们来解释一下。

  • 重子：对于每一个非叶子节点，它的儿子中以那个儿子为根的子树节点数最大的儿子为该节点的重子 。
  • 轻子：跟重子相反，一个点不是重子就是轻子（叶子节点除外），对于每一个非叶子节点，它的子中非重儿子的剩下所有儿子即为轻子。
  • 重边：一个父亲连接他的重子的边称为重边。
  • 轻边：跟重边相反，每一条边不是重边就是轻边。
  • 重链：重链的要求非常难，一点是相邻的重边连起来一个重子的链就是重链。
    如果有还不理解的同学，我们来画一张图来找一找这些东西在哪里。请添加图片描述

需要的函数

第一个dfs

这个dfs他到底要解决什么问题呢？其实有这么用处。

  • 标记每一个点的深度
  • 预处理出每一个点的父亲
  • 标记每个非叶子节点的子树大小(含它自己)
  • 标记每个非叶子节点的重儿子编号son[]
void dfs1(int x,int f,int deep)
{//x当前节点，f父亲，deep深度 
	dep[x]=deep;//标记每个点的深度 
	fa[x]=f;//标记每个点的父亲 
	siz[x]=1;//标记每个非叶子节点的子树大小 
	int maxn=-1;//记录重儿子的儿子数 
	for(int i=beg[x];i;i=nex[i])
	{
		int y=to[i];
		if(y==f)
			continue;//若为父亲则continue 
		dfs1(y,x,deep+1);//dfs其儿子 
		siz[x]+=siz[y];//把它的儿子数加到它身上 
		if(siz[y]>maxn)
			son[x]=y,maxn=siz[y];//标记每个非叶子节点的重儿子编号 
	}
}
第二个dfs

第二个dfs的目的其实跟第一个是差不多的，同样是预处理，我们先列出来看看。

  • 标记每个点的新编号
  • 赋值每个点的初始值到新编号上
  • 处理每个点所在链的顶端
  • 处理每条链
void dfs2(int x,int topf){//x当前节点，topf当前链的最顶端的节点 
	id[x]=++cnt;//标记每个点的新编号 
	wt[cnt]=w[x];//把每个点的初始值赋到新编号上来 
	top[x]=topf;//这个点所在链的顶端 
	if(!son[x])
		return;//如果没有儿子则返回 
	dfs2(son[x],topf);//按先处理重儿子，再处理轻儿子的顺序递归处理 
	for(int i=beg[x];i;i=nex[i])
	{
		int y=to[i];
		if(y==fa[x]||y==son[x])
			continue;
		dfs2(y,y);//对于每一个轻儿子都有一条从它自己开始的链 
	}
}
树剖部分

敲一下黑板，这是最重要的部分，因为第二个dfs的便利顺序是先重子，再轻子，然后就不难得到一个很有用的东西：

  • 因为顺序是先重再轻，所以每一条重链的新编号是连续的
  • 因为是dfs，所以每一个子树的新编号也是连续的
    然后我们搬出题目让我们干的事情，一件一件分析：
  • 处理任意两点间路径上的点权和
  • 处理一点及其子树的点权和
  • 修改任意两点间路径上的点权
  • 修改一点及其子树的点权
  1. 处理任意两点间路径时：
    设所在链顶端的深度更深的那个点为 x x x 点 a n s ans ans 加上 x x x 点到 x x x 所在链顶端 这一段区间的点权和，把 x x x 跳到 x x x 所在链顶端的那个点的上面一个点。可能会有一点点抽象，我们画一个图帮助理解一下。请添加图片描述
    那么好的，在分析一下，因为这先序号都是连续的，所以怎么维护呢，可以使用线段树，不会的可以翻往期的笔记。时间复杂度就是 O ( log ⁡ 2 n ) O\left(\log^2n\right) O(log2n)
inline int qRange(int x,int y){
	int ans=0;
	while(top[x]!=top[y]){//当两个点不在同一条链上 
		if(dep[top[x]]<dep[top[y]])swap(x,y);//把x点改为所在链顶端的深度更深的那个点
		res=0;
		query(1,1,n,id[top[x]],id[x]);//ans加上x点到x所在链顶端 这一段区间的点权和
		ans+=res;
		ans%=mod;//按题意取模 
		x=fa[top[x]];//把x跳到x所在链顶端的那个点的上面一个点
	}
	//直到两个点处于一条链上
	if(dep[x]>dep[y])
		swap(x,y);//把x点深度更深的那个点
	res=0;
	query(1,1,n,id[x],id[y]);//这时再加上此时两个点的区间和即可
	ans+=res;
	return ans%mod;
}
  1. 处理一点及其子树的点权和：想到记录了每个非叶子节点的子树大小(含它自己)，并且每个子树的新编号都是连续的,直接线段树区间查询即可，时间复杂度 O ( log ⁡ n ) O\left(\log n\right) O(logn)
inline int qSon(int x){
	res=0;
	query(1,1,n,id[x],id[x]+siz[x]-1);//子树区间右端点为id[x]+siz[x]-1 
	return res;
}

下面是区间修改的，跟查询基本一样：

inline void updRange(int x,int y,int k){
	k%=mod;
	while(top[x]!=top[y]){
		if(dep[top[x]]<dep[top[y]])swap(x,y);
		update(1,1,n,id[top[x]],id[x],k);
		x=fa[top[x]];
	}
	if(dep[x]>dep[y])swap(x,y);
	update(1,1,n,id[x],id[y],k);
}

inline void updSon(int x,int k){
	update(1,1,n,id[x],id[x]+siz[x]-1,k);
}
建树

普通的线段树，不多说了。

代码部分

#include<bits/stdc++.h>
using namespace std;
#define mid ((l+r)>>1)
#define lson rt<<1,l,mid
#define rson rt<<1|1,mid+1,r
#define len (r-l+1)
const int maxn=200000+10;
int n,m,r,mod;//见题意 
int e,beg[maxn],nex[maxn],to[maxn],w[maxn],wt[maxn];//链式前向星数组，w、wt初始点权数组 
int a[maxn<<2],laz[maxn<<2];//线段树数组、lazy懒标记 
int son[maxn],id[maxn],fa[maxn],cnt,dep[maxn],siz[maxn],top[maxn];//son重子编号,id新编号,fa父亲节点,cnt dfs_clock/dfs序,dep深度,siz子树大小,top当前链顶端节点
int res;
void add(int x,int y){//链式前向星加边 
    to[++e]=y;
    nex[e]=beg[x];
    beg[x]=e;
}
//线段树操作，不多说了，看往期笔记 
void pushdown(int rt,int lenn)
{
	laz[rt<<1]+=laz[rt];
	laz[rt<<1|1]+=laz[rt];
    a[rt<<1]+=laz[rt]*(lenn-(lenn>>1));
    a[rt<<1|1]+=laz[rt]*(lenn>>1);
    a[rt<<1]%=mod;
    a[rt<<1|1]%=mod;
    laz[rt]=0;
}
void build(int rt,int l,int r)
{
    if(l==r){
        a[rt]=wt[l];
        if(a[rt]>mod)a[rt]%=mod;
        return;
    }
    build(lson);
    build(rson);
    a[rt]=(a[rt<<1]+a[rt<<1|1])%mod;
}
void query(int rt,int l,int r,int L,int R)
{
	if(L<=l&&r<=R)
	{
		res+=a[rt];
		res%=mod;
		return;
	}
	else
	{
		if(laz[rt])
			pushdown(rt,len);
		if(L<=mid)
			query(lson,L,R);
		if(R>mid)
			query(rson,L,R);
	}
}
void update(int rt,int l,int r,int L,int R,int k)
{
    if(L<=l&&r<=R)
	{
		laz[rt]+=k;
		a[rt]+=k*len;
	}
	else
	{
		if(laz[rt])
			pushdown(rt,len);
		if(L<=mid)
			update(lson,L,R,k);
		if(R>mid)
			update(rson,L,R,k);
		a[rt]=(a[rt<<1]+a[rt<<1|1])%mod;
	}
} 
int qRange(int x,int y)
{
	int ans=0;
	while(top[x]!=top[y])//当两个点不在同一条链上
	{ 
		if(dep[top[x]]<dep[top[y]])
			swap(x,y);//把x点改为所在链顶端的深度更深的那个点
		res=0;
		query(1,1,n,id[top[x]],id[x]);//ans加上x点到x所在链顶端 这一段区间的点权和
		ans+=res;
		ans%=mod;//按题意取模 
		x=fa[top[x]];//把x跳到x所在链顶端的那个点的上面一个点
	}
	//直到两个点处于一条链上，跟LCA类似 
	if(dep[x]>dep[y])
		swap(x,y);//把x点深度更深的那个点
	res=0;
	query(1,1,n,id[x],id[y]);//这时再加上此时两个点的区间和即可
	ans+=res;
	return ans%mod;
}
void updRange(int x,int y,int k)//同上 
{
	k%=mod;
	while(top[x]!=top[y])
	{
		if(dep[top[x]]<dep[top[y]])
			swap(x,y);
		update(1,1,n,id[top[x]],id[x],k);
		x=fa[top[x]];
	}
	if(dep[x]>dep[y])swap(x,y);
	update(1,1,n,id[x],id[y],k);
}
int qSon(int x)
{
	res=0;
	query(1,1,n,id[x],id[x]+siz[x]-1);//子树区间右端点为id[x]+siz[x]-1 
	return res;
}
void updSon(int x,int k){//同上 
	update(1,1,n,id[x],id[x]+siz[x]-1,k);
}
void dfs1(int x,int f,int deep){//x当前节点，f父亲，deep深度 
	dep[x]=deep;//标记每个点的深度 
	fa[x]=f;//标记每个点的父亲 
	siz[x]=1;//标记每个非叶子节点的子树大小 
	int maxson=-1;//记录重儿子的儿子数 
	for(int i=beg[x];i;i=nex[i])
	{
		int y=to[i];
		if(y==f)
			continue;//若为父亲则continue 
		dfs1(y,x,deep+1);//dfs其儿子 
		siz[x]+=siz[y];//把它的儿子数加到它身上 
		if(siz[y]>maxson)
			son[x]=y,maxson=siz[y];//标记每个非叶子节点的重儿子编号 
	}
}

void dfs2(int x,int topf){//x当前节点，topf当前链的最顶端的节点 
	id[x]=++cnt;//标记每个点的新编号 
	wt[cnt]=w[x];//把每个点的初始值赋到新编号上来 
	top[x]=topf;//这个点所在链的顶端 
	if(!son[x])
		return;//如果没有儿子则返回 
	dfs2(son[x],topf);//按先处理重儿子，再处理轻儿子的顺序递归处理 
	for(int i=beg[x];i;i=nex[i])
	{
		int y=to[i];
		if(y==fa[x]||y==son[x])
			continue;
		dfs2(y,y);//对于每一个轻儿子都有一条从它自己开始的链 
	}
}
int main()
{
    cin>>n>>m>>r>>mod; 
    for(int i=1;i<=n;i++)
		cin>>w[i];
    for(int i=1;i<n;i++){
        int u,v;
        cin>>u>>v;
        add(u,v);
		add(v,u);
    }
    dfs1(r,0,1);
    dfs2(r,r);
    build(1,1,n);
	while(m--)
	{
        int k,x,y,z;
        cin>>k;
        if(k==1)
		{
            cin>>x>>y>>z;
            updRange(x,y,z);
        }
        else if(k==2)
		{
            cin>>x>>y;
            printf("%d\n",qRange(x,y));
        }
        else if(k==3)
		{
            cin>>x>>y;
            updSon(x,y);
        }
        else
		{
            cin>>x;
            printf("%d\n",qSon(x));
    	}
    }
}
骑狗看夕阳
关注
【树上莫队C++】Count on Tree II（欧拉序降维，树链剖分求最近共同祖先LCA）
qq_73928885的博客
09-22 366
像 `树` 这种二维的如果可以进行降维（将树转化成链处理）处理的话，也可以使用 `莫队算法` 处理。
树链剖分 学习笔记
不知所云的博客
05-05 264
写在前面，算法笔记只是针对个人复习用，要想学习这个算法还是要看更详细的博客或视频讲解。 树链剖分 基本概念不讲，讲一下各个函数的作用，以及基本实现原理； 首先要知道树链剖分的作用就是把树上问题转化为线性问题； 线性问题总所周知就有区间问题，有区间问题就有线段树这种东西； 所以树链剖分就是先把树拆成一条条链（线性），然后用线段树维护区间就行； 怎么拆是最难的，我觉得搞懂dfs序是前提，因为就是根据d...
树链剖分基础及进阶
qq_42852687的博客
02-03 574
树链剖分和树上启发式合并一，树链剖分1，重链剖分剖分过程索引过程板子：（小清新写法）树剖应用1，边权转点3，注意事项： 一，树链剖分 思路： 把树上问题转化到线段树上维护，树上转为序列 1，重链剖分 意义：重链剖分可以将树上的任意一条路径划分成不超过O(logn)O(log n)O(logn)条连续的链，每条链上的点深度互不相同（即是自底向上的一条链，链上所有点的 LCA 为链的一个端点）（一种求lca的新方法！！） 重子节点 表示其子节点中子树最大的子结点。如果有多个子树最大的子结点，取其一；如果没有
树链剖分—学习笔记
niiick
03-07 279
树链剖分
树链剖分学习笔记（自用）
12-25
树链剖分学习笔记（自用）
算法学习笔记：树链剖分
Plozia 的小窝
03-09 420
算法学习笔记：树链剖分1. 前言2. 详解 1. 前言 树链剖分，是一种树上的算法，将树划分为若干条链，然后利用线段树来处理树上信息。 在学树链剖分之前，你需要了解的知识： DFS 序。 线段树的基础操作。 2. 详解 模板题：P3384 【模板】轻重链剖分 ...
『从入门到入土』树链剖分学习笔记
最新发布
luogu_551100的博客
01-17 414
因此，每个连通块恰好有一个点的父亲节点为空。$\quad$ $1$. 情况 $1$ ：$root$ 在 $x$ 的子树中，也在 $y$ 的子树中，即 $lca(x,root)=x$ && $lca(y,root)=y$ ，此时 $LCA(x,y)$ 是 $y$ ，因为图要反过来看(以 $root$ 为根)$\quad$ $2$. 情况 $2$ ： $root$ 在 $x$ 的子树中，但不在 $y$ 的子树中，即 $lca(x,root)$ ，此时 $LCA(x,y)$ 是 $lca(y,root)$。
树链剖分学习日记
既然弱小，就只顾变强就是了
11-27 460
树链剖分 【11月27日星期二晴】 先【下认识树链剖分的概念】 从大佬处摘录而来，先认识下概念。 树链剖分就是对一棵树分成几条链，把树形变为线性，减少处理难度 需要处理的问题： 将树从X到ý结点最短路径上所有节点的值都加上ž 求树从X到ý结点最短路径上所有节点的值之和 将以X为根节点的子树内所有节点值都加上ž 求以X为根节点的子树内所有节点值之和 概念 重儿子：对于每一个非...
NOIP树链剖分详解与实现
"NOIP树链剖分是用于优化树形结构数据的处理效率的一种算法，常用于解决涉及树路径信息维护的问题。该算法的主要目标是将一棵树划分为若干条链，每条链的数据结构可以高效地进行操作，使得在树上进行查询或更新操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值