树链剖分模板

最新推荐文章于 2021-07-25 17:09:52 发布
最新推荐文章于 2021-07-25 17:09:52 发布
阅读量195 收藏
点赞数
分类专栏： 模板 树链剖分
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DyingShu/article/details/82947265
版权

啃了好久，终于把树链剖分给啃下来了

前置知识：dfs序，lca，线段树等

算法思想：把树拆成一条一条的链，然后用数据结构维护。

在这里插入图片描述

首先定义几个概念：

  • 子树大小：以某一节点为根节点的子树中节点的总数，包括该点。
  • 重节点：在某一节点的所有子节点中，子树大小最大的节点。
  • 轻节点：不是重儿子的节点。特殊的，根节点是轻节点。
  • 重链：重节点依次相连形成的链。

具体实现：以luogu3384 【模板】树链剖分 为例

1.dfs1

这个dfs要处理这些事情：

  • 每个节点的深度 d e p dep dep
  • 每个节点的父亲 f a fa fa
  • 每个节点的子树大小 s i z e size size
  • 每个节点的重儿子节点 s o n son son
void dfs1(int u, int f, int d){
	dep[u] = d, fa[u] = f, size[u] = 1, son[u] = 0;
	for(int i = fir[u]; i != -1; i = nxt[i]){
		int v = to[i];
		if(v == f) continue;
		dfs1(v, u, d + 1);
		size[u] += size[v];
		if(size[v] > size[son[u]]) son[u] = v;
	}
}

2.dfs2

这个dfs要做这些事情：

  • dfs序。因为要用数据结构维护每条链，需要让重链上的每一个节点的编号 d f n dfn dfn连续。相应的，还要处理出每个编号所对应的节点 i d id id。
  • 该节点所在重链链头top。
void dfs2(int u, int topf){
	dfn[u] = ++num, id[num] = u, top[u] = topf;
	if(!son[u]) return; dfs2(son[u], topf);
	for(int i = fir[u]; i != -1; i = nxt[i]){
		int v = to[i];
		if(v != son[u] && v != fa[u]) dfs2(v, v);
	}
}

轻重链划分后，就可以证明复杂度了（以下省略1w字）
也可以看这里

3.线段树

维护的数据结构我们用线段树来解决。
你可以想象，轻链和重链都按照dfs一条一条地躺在了一条线上
事实上dfs序有许多优秀的性质。比如，一颗子树里的dfs序总是连续的，这意味着维护子树就可以转化为维护区间；同理，维护重链也可以转换成维护区间了。

#define mid ((l + r) >> 1)
int val[MAXN << 2], tag[MAXN << 2];
inline void pushup(int u){
	val[u] = (val[u << 1] + val[u << 1 | 1]) % p;
}
inline void pushdown(int u, int l, int r){
	if(tag[u]){
		val[u << 1] = (val[u << 1] + (mid - l + 1) * tag[u]) % p;
		val[u << 1 | 1] = (val[u << 1 | 1] + (r - mid) * tag[u]) % p;
		tag[u << 1] = (tag[u << 1] + tag[u]) % p;
		tag[u << 1 | 1] = (tag[u << 1 | 1] + tag[u]) % p;
		tag[u] = 0;
	}
}
void build(int u, int l, int r){
	if(l == r){
		val[u] = w[id[l]] % p; return;
	}
	build(u << 1, l, mid); build(u << 1 | 1, mid + 1, r);
	pushup(u);
}
void modify(int u, int l, int r, int L, int R, int k){
	if(L <= l && r <= R){
		val[u] = (val[u] + (r - l + 1) * k) % p;
		tag[u] = (tag[u] + k) % p;
		return;
	}
	pushdown(u, l, r);
	if(L <= mid) modify(u << 1, l, mid, L, R, k);
	if(R > mid) modify(u << 1 | 1, mid + 1, r, L, R, k);
	pushup(u);
}
int query(int u, int l, int r, int L, int R){
	if(L <= l && r <= R) return val[u];
	pushdown(u, l, r); int ret = 0;
	if(L <= mid) ret = (ret + query(u << 1, l, mid, L, R)) % p;
	if(R > mid) ret = (ret + query(u << 1 | 1, mid + 1, r, L, R)) % p;
	return ret;
}
#undef mid

要注意的一点是建树时取的初值是 w [ i d [ u ] ] w[id[u]] w[id[u]]。

四个操作

1.修改路径

类似于求lca的思想，两个点向上跳，每跳一条链就对这条链进行修改，最后跳到同一条链的时候修改两点之间的部分。

void addpath(int x, int y, int k){
	while(top[x] != top[y]){
		if(dep[top[x]] < dep[top[y]]) swap(x, y);
		modify(1, 1, n, dfn[top[x]], dfn[x], k);
		x = fa[top[x]];
	}
	if(dep[x] < dep[y]) swap(x, y);
	modify(1, 1, n, dfn[y], dfn[x], k);
}

2.查询路径

与修改路径差不多，不同的是把修改换成了统计答案。

int querypath(int x, int y){
	int ret = 0;
	while(top[x] != top[y]){
		if(dep[top[x]] < dep[top[y]]) swap(x, y);
		ret = (ret + query(1, 1, n, dfn[top[x]], dfn[x])) % p;
		x = fa[top[x]];
	}
	if(dep[x] < dep[y]) swap(x, y);
	ret = (ret + query(1, 1, n, dfn[y], dfn[x])) % p;
	return ret;
}

3.修改子树

前面我们说过一颗子树里的dfs序总是连续的，具体就是从 d f n [ i ] dfn[i] dfn[i]到 d f n [ i ] + s i z e [ i ] − 1 dfn[i]+size[i]-1 dfn[i]+size[i]−1的区间。

void addsubtree(int x, int k){
	modify(1, 1, n, dfn[x], dfn[x] + siz[x] - 1, k);
}

4.查询子树

同修改子树。

int querysubtree(int x){
	return query(1, 1, n, dfn[x], dfn[x] + siz[x] - 1);
}

全部代码：

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int MAXN = 100005;
const int MAXM = 100005;

int n, m, root, p, w[MAXN];
int fir[MAXN], nxt[MAXM << 1], to[MAXM << 1], len[MAXM << 1], cnt;
int dep[MAXN], fa[MAXN], siz[MAXN], son[MAXN];
int dfn[MAXN], id[MAXN], top[MAXN], num;

inline int read(){
	int k = 0, f = 1; char ch = getchar();
	while(ch < '0' || ch > '9'){if(ch == '-') f = -1; ch = getchar();}
	while(ch >= '0' && ch <= '9'){k = k * 10 + ch - '0'; ch = getchar();}
	return k * f;
}

inline void add_edge(int a, int b, int l){
	len[cnt] = l; to[cnt] = b;
	nxt[cnt] = fir[a]; fir[a] = cnt++;
}

void dfs1(int u, int f, int d){
	dep[u] = d, fa[u] = f, siz[u] = 1, son[u] = 0;
	for(int i = fir[u]; i != -1; i = nxt[i]){
		int v = to[i];
		if(v == f) continue;
		dfs1(v, u, d + 1);
		siz[u] += siz[v];
		if(siz[v] > siz[son[u]]) son[u] = v;
	}
}

void dfs2(int u, int topf){
	dfn[u] = ++num, id[num] = u, top[u] = topf;
	if(!son[u]) return; dfs2(son[u], topf);
	for(int i = fir[u]; i != -1; i = nxt[i]){
		int v = to[i];
		if(v == fa[u] || v == son[u]) continue;
		dfs2(v, v);
	}
}

#define mid ((l + r) >> 1)
int val[MAXN << 2], tag[MAXN << 2];
inline void pushup(int u){
	val[u] = (val[u << 1] + val[u << 1 | 1]) % p;
}
inline void pushdown(int u, int l, int r){
	if(tag[u]){
		val[u << 1] = (val[u << 1] + (mid - l + 1) * tag[u]) % p;
		val[u << 1 | 1] = (val[u << 1 | 1] + (r - mid) * tag[u]) % p;
		tag[u << 1] = (tag[u << 1] + tag[u]) % p;
		tag[u << 1 | 1] = (tag[u << 1 | 1] + tag[u]) % p;
		tag[u] = 0;
	}
}
void build(int u, int l, int r){
	if(l == r){
		val[u] = w[id[l]] % p; return;
	}
	build(u << 1, l, mid); build(u << 1 | 1, mid + 1, r);
	pushup(u);
}
void modify(int u, int l, int r, int L, int R, int k){
	if(L <= l && r <= R){
		val[u] = (val[u] + (r - l + 1) * k) % p;
		tag[u] = (tag[u] + k) % p;
		return;
	}
	pushdown(u, l, r);
	if(L <= mid) modify(u << 1, l, mid, L, R, k);
	if(R > mid) modify(u << 1 | 1, mid + 1, r, L, R, k);
	pushup(u);
}
int query(int u, int l, int r, int L, int R){
	if(L <= l && r <= R) return val[u];
	pushdown(u, l, r); int ret = 0;
	if(L <= mid) ret = (ret + query(u << 1, l, mid, L, R)) % p;
	if(R > mid) ret = (ret + query(u << 1 | 1, mid + 1, r, L, R)) % p;
	return ret;
}
#undef mid

void addpath(int x, int y, int k){
	while(top[x] != top[y]){
		if(dep[top[x]] < dep[top[y]]) swap(x, y);
		modify(1, 1, n, dfn[top[x]], dfn[x], k);
		x = fa[top[x]];
	}
	if(dep[x] < dep[y]) swap(x, y);
	modify(1, 1, n, dfn[y], dfn[x], k);
}
int querypath(int x, int y){
	int ret = 0;
	while(top[x] != top[y]){
		if(dep[top[x]] < dep[top[y]]) swap(x, y);
		ret = (ret + query(1, 1, n, dfn[top[x]], dfn[x])) % p;
		x = fa[top[x]];
	}
	if(dep[x] < dep[y]) swap(x, y);
	ret = (ret + query(1, 1, n, dfn[y], dfn[x])) % p;
	return ret;
}
void addsubtree(int x, int k){
	modify(1, 1, n, dfn[x], dfn[x] + siz[x] - 1, k);
}
int querysubtree(int x){
	return query(1, 1, n, dfn[x], dfn[x] + siz[x] - 1);
}


signed main(){
	memset(fir, -1, sizeof(fir)); cnt = 0;
	n = read(), m = read(), root = read(), p = read();
	for(int i = 1; i <= n; i++){
		w[i] = read();
	}
	for(int i = 1; i < n; i++){
		int x = read(), y = read();
		add_edge(x, y, 1);
		add_edge(y, x, 1);
	}
	dfs1(root, 0, 0);
	dfs2(root, root);
	build(1, 1, n);
	for(int i = 1; i <= m; i++){
		int opt = read();
		if(opt == 1){
			int x = read(), y = read(), z = read();
			addpath(x, y, z % p);
		}
		if(opt == 2){
			int x = read(), y = read();
			int ans = querypath(x, y);
			printf("%lld\n", ans);
		}
		if(opt == 3){
			int x = read(), z = read();
			addsubtree(x, z % p);
		}
		if(opt == 4){
			int x = read();
			int ans = querysubtree(x);
			printf("%lld\n", ans);
		}
	}
	return 0;
}

tips:写完之后发现还多简单的

QAQwdd
关注
专栏目录
树链剖分模板 边权、点权区别
tangzhide123yy的博客
07-29 2454
熟练剖分详解见:https://blog.csdn.net/tangzhide123yy/article/details/77532880 熟练剖分一般有如下几个步骤: 1.dfs1（）求出fa,deep,size,son 2.dfs2（）求出top,p 3.add（）/Query （）树链剖分核心部分 4.updata（）线段树更新操作(如单点修改，区间修改) 5.query（）线段...
树链剖分（模板）
cy41的博客
08-07 281
一个个人认为讲的比较好的B站up主：【AgOHの算法胡扯】树链剖分 前置知识：图的存储及遍历，dfs序（只存第一次被访问），线段树区间操作。 树链剖分支持的操作：（点权以及边权是可以互相转化的，这里只说点权。） upd：2020/1/15最下方新增边剖示例。 修改及查询以x为根的子树权值 修改及查询一条链上的权值（链的定义为：树上两点的最短路径） int index1;//时间戳; ...
树链剖分[模板]
weixin_30700977的博客
08-23 80
传送门 树链剖分 树链剖分就是把一颗树分成很多条链，然后把链上的数据进行瞎搞操作（本题是用线段树区间修改） 一步一步慢慢讲： 1. 从根节点开始对整颗树进行一次遍历 求出每个节点子树的大小，父节点，深度和重儿子 重儿子指 儿子子树大小最大 的儿子节点 （做这些都是为了后面瞎搞） 2. 再来一次遍历.. 这次求出每个节点 所在重链的顶端，在dfs序中的编号（要让重链的节点编号连续）...
树链剖分详解
weixin_30641465的博客
05-10 99
转载请注明出处，部分内容引自banananana大神的博客 别说你不知道什么是树╮(─▽─)╭（帮你百度一下） 前置知识：　　dfs序　　线段树 先来回顾两个问题：1，将树从x到y结点最短路径上所有节点的值都加上z 这也是个模板题了吧 我们很容易想到，树上差分可以以O(n+m)的优秀复杂度解决这个问题 2，求树从x到y结点最短路径上所有节点的值之和 lca大水题，我们又很容易...
树链剖分——树链剖分模板
fdxgcw的博客
07-25 319
添加链接描述 给定一棵树，树中包含 n 个节点（编号 1∼n），其中第 i 个节点的权值为 ai。 初始时，1 号节点为树的根节点。 现在要对该树进行 m 次操作，操作分为以下 4 种类型： 1 u v k，修改路径上节点权值，将节点 u 和节点 v 之间路径上的所有节点（包括这两个节点）的权值增加 k。 2 u k，修改子树上节点权值，将以节点 u 为根的子树上的所有节点的权值增加 k。 3 u v，询问路径，询问节点 u 和节点 v 之间路径上的所有节点（包括这两个节点）的权值和。 4 u，询问子树，询
树链剖分模板题
05-19
#include #include #include #define N 30003 #define INF 2147483647 using namespace std; int n,f[N][20],dep[N],siz[N],son[N],top[N],tot,pos[N],w[N]; int Max[N*4],Sum[N*4];...vector <int> to[N];...
[模板] 树链剖分
Memories Do Not Open
05-03 262
线段树的妙用
树链剖分模版
静静地码
11-06 443
摘自http://blog.sina.com.cn/s/blog_6974c8b20100zc61.html 稍有改动“在一棵树上进行路径的修改、求极值、求和”乍一看只要线段树就能轻松解决，实际上，仅凭线段树是不能搞定它的。我们需要用到一种貌似高级的复杂算法——树链剖分。树链，就是树上的路径。剖分，就是把路径分类为重链和轻链。 记size[v]表示以v为根的子树的节点数，dep[v]表示v的深度(
树链剖分 模板
everlasting的博客
10-03 268
bzoj 1036 #include #include #include #include #include #define inf 999999999 using namespace std; struct node{ int Max,sum; int l,r; }tree[120020]; int n; int w[30030],son[30030],totree[30030],
P3384 【模板】树链剖分
weixin_34075551的博客
12-31 131
P3384 【模板】树链剖分 题目描述 如题，已知一棵包含N个结点的树（连通且无环），每个节点上包含一个数值，需要支持以下操作： 操作1： 格式： 1 x y z 表示将树从x到y结点最短路径上所有节点的值都加上z 操作2： 格式： 2 x y 表示求树从x到y结点最短路径上所有节点的值之和 操作3： 格式： 3 x z 表示将以x为根节点的子树内所有节点值都加上z 操作4： 格式： ...
洛谷P3384树链剖分模板详解与C++实现
本篇笔记主要围绕数据结构中的树链剖分（也称为重链剖分）进行深入讲解。树链剖分是一种将一棵树分解成若干个连续的子树的算法，用于高效地支持查询和修改树中特定路径上的节点值。该技术常用于动态规划和在线问题的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值