[模版] 树链剖分

已于 2022-09-28 20:00:22 修改
阅读量159 收藏
点赞数
分类专栏： 数据结构 模板整理 文章标签： 1024程序员节
于 2021-10-24 16:31:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50815157/article/details/120935860
版权

树链剖分是解决树上问题的一种常见数据结构，对于树上路径修改及路径信息查询等问题有着较优的复杂度。树链剖分分为两种：重链剖分和长链剖分，通常说的树链剖分指的是重链剖分。

一些名词:

重儿子：每个点的子树中，子树大小(即节点数)最大的子节点（如果有多个节点，任选一个）
轻儿子：除重儿子外的其他子节点
重边：每个节点与其重儿子间的边
轻边：每个节点与其轻儿子间的边
重链：重边连成的链
轻链：轻边连成的链

剖分后的树有一个性质：从根到某一点的路径上轻链、重链的个数都不大于 l o g n logn logn。

树链剖分就是将树中每一个点重新编号，编号的过程用 d f s dfs dfs来进行，从 1 1 1开始，但是不是随便 d f s dfs dfs的，对于一个节点 u u u，我们总是先进入它的重儿子搜索。进行完重新编号后，树中的任意一条重链上的点的编号一定是连续的。
然后我们可以对树的新编号建立一个线段树来维护一些值。

模版题：

在这里插入图片描述
在这里插入图片描述

#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <vector>
#include <string>
#include <algorithm>
#define INF 0x3f3f3f3f

using namespace std;

typedef long long LL;

const int N = 1e5 + 10;

int n, m, w[N];
int tot, id[N], nw[N];
int sz[N], dep[N], top[N], fa[N], son[N];
//sz[i]:子树i的大小    dep[i]:i点的深度
//top[i]:点i所在链的顶点    fa[i]:点i的父节点
//son[i]:点i的重儿子
int idx, head[N], e[N<<1], ne[N<<1];
struct Node
{
	int l, r;
	LL add, sum;
	#define ls (u << 1)
	#define rs (u << 1 | 1)
} tr[N * 4];

void add(int u, int v)
{
	e[++ idx] = v, ne[idx] = head[u], head[u] = idx;
}

//dfs1可以求出每个点的深度dep，子树大小sz，每个点的父节点fa，每个点的重儿子son
void dfs1(int u, int father, int depth) //当前节点u，父节点fa，当前深度depth
{
	dep[u] = depth, fa[u] = father, sz[u] = 1;
	for(int i = head[u]; i; i = ne[i])
	{
		int v = e[i];
		if(v == father)	continue;
		dfs1(v, u, depth + 1);
		sz[u] += sz[v];
		if(sz[son[u]] < sz[v])	son[u] = v;
	}
}

//dfs2可以求出每个点所在链的链顶点top，每个点的新编号id，每个新编号对应的点权nw
void dfs2(int u, int t) //当前的u，u所在链的顶点t
{
	id[u] = ++ tot, nw[tot] = w[u], top[u] = t;
	if(!son[u])	return ;//叶节点
	dfs2(son[u], t); //先递归重儿子
	for(int i = head[u]; i; i = ne[i]) //然后在遍历轻儿子
	{
		int v = e[i];
		if(v == fa[u] || v == son[u])	continue;
		dfs2(v, v); //轻儿子一定是所在链的链顶
	}
}

/*------------------------正常线段树代码-----------------------------*/

void pushup(int u)
{
	tr[u].sum = tr[ls].sum + tr[rs].sum;
}

void pushdown(int u)
{
	if(!tr[u].add)	return ;
	LL t = tr[u].add; tr[u].add = 0;
	tr[ls].sum += t * (tr[ls].r - tr[ls].l + 1);
	tr[rs].sum += t * (tr[rs].r - tr[rs].l + 1);
	tr[ls].add += t, tr[rs].add += t;
}

void build(int u, int l, int r)
{
	tr[u] = {l, r, 0, nw[r]};
	if(l == r)	return ;
	int mid = l + r >> 1;
	build(ls, l, mid), build(rs, mid + 1, r);
	pushup(u);
}

void update(int u, int l, int r, int k)
{
	if(l <= tr[u].l && tr[u].r <= r)
	{
		tr[u].add += k;
		tr[u].sum += k * (tr[u].r - tr[u].l + 1);
		return ;
	}
	pushdown(u);
	int mid = tr[u].l + tr[u].r >> 1;
	if(l <= mid)	update(ls, l, r, k);
	if(r > mid)	update(rs, l, r, k);
	pushup(u);
}

LL query(int u, int l, int r)
{
	if(l <= tr[u].l && tr[u].r <= r)	return tr[u].sum;
	pushdown(u);
	int mid = tr[u].l + tr[u].r >> 1;
	LL res = 0;
	if(l <= mid)	res += query(ls, l, r);
	if(r > mid)	res += query(rs, l, r);
	return res;
}

/*------------------------------------------------------------------*/

void update_path(int u, int v, int k) //将树上u-->v的路径中的所有点加上k
{
	while(top[u] != top[v])
	{
		if(dep[top[u]] < dep[top[v]])	swap(u, v);
		update(1, id[top[u]], id[u], k);
		u = fa[top[u]];
	}
	if(dep[u] < dep[v])	swap(u, v);
	update(1, id[v], id[u], k);
}

LL query_path(int u, int v) //求树上u-->v的路径中的所有点的权值和
{
	LL res = 0;
	while(top[u] != top[v])
	{
		if(dep[top[u]] < dep[top[v]])	swap(u, v);
		res += query(1, id[top[u]], id[u]);
		u = fa[top[u]];
	}
	if(dep[u] < dep[v])	swap(u, v);
	res += query(1, id[v], id[u]);
	return res;
}

void update_tree(int u, int k) //将以u为根的子树中的每一个点都加k
{
	update(1, id[u], id[u] + sz[u] - 1, k); //该子树中所有点的新编号一定是连续的一段
}

LL query_tree(int u) //询问以u为根的子树的权值和
{
	return query(1, id[u], id[u] + sz[u] - 1);
}

int main()
{
#ifdef LOCAL
	freopen("in.in", "r", stdin);
	freopen("out.out", "w", stdout);
#endif

	scanf("%d", &n);
	for(int i = 1; i <= n; i ++)	scanf("%d", &w[i]);
	for(int i = 1; i < n; i ++)
	{
		int a, b;
		scanf("%d%d", &a, &b);
		add(a, b), add(b, a);
	}

	dfs1(1, -1, 1);
	dfs2(1, 1);
	build(1, 1, n);

	scanf("%d", &m);
	while(m --)
	{
		int opt, u, v, k;
		scanf("%d%d", &opt, &u);
		if(opt == 1)
		{
			scanf("%d%d", &v, &k);
			update_path(u, v, k);
		}
		else if(opt == 2)
		{
			scanf("%d", &k);
			update_tree(u, k);
		}
		else if(opt == 3)
		{
			scanf("%d", &v);
			printf("%lld\n", query_path(u, v));
		}
		else	printf("%lld\n", query_tree(u));
	}

	return 0;
}

「ZJOI2008」树的统计

在这里插入图片描述

#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <vector>
#include <string>
#include <algorithm>
#define INF 0x3f3f3f3f

using namespace std;

typedef long long LL;

const int N = 3e4 + 10;

int n, m, w[N];
int tot, id[N], nw[N];
int sz[N], dep[N], fa[N], top[N], son[N];
int idx, head[N], e[N<<1], ne[N<<1];

void add(int u, int v)
{
	e[++ idx] = v, ne[idx] = head[u], head[u] = idx;
}

void dfs1(int u, int pre, int depth)
{
	dep[u] = depth, fa[u] = pre, sz[u] = 1;
	for(int i = head[u]; i; i = ne[i])
	{
		int v = e[i];
		if(v == pre)	continue;
		dfs1(v, u, depth + 1);
		sz[u] += sz[v];
		if(sz[son[u]] < sz[v])	son[u] = v;
	}
}

void dfs2(int u, int t)
{
	id[u] = ++ tot, nw[tot] = w[u], top[u] = t;
	if(!son[u])	return ;
	dfs2(son[u], t);
	for(int i = head[u]; i; i = ne[i])
	{
		int v = e[i];
		if(v == fa[u] || v == son[u])	continue;
		dfs2(v, v);
	}
}

struct Node
{
	int l, r;
	LL mx, sum;
	#define ls (u << 1)
	#define rs (u << 1 | 1)
} tr[N * 4];

void pushup(int u)
{
	tr[u].mx = max(tr[ls].mx, tr[rs].mx);
	tr[u].sum = tr[ls].sum + tr[rs].sum;
}

void build(int u, int l, int r)
{
	tr[u] = {l, r, nw[l], nw[l]};
	if(l == r)	return ;
	int mid = l + r >> 1;
	build(ls, l, mid), build(rs, mid + 1, r);
	pushup(u);
}

void update(int u, int x, int v)
{
	if(tr[u].l == tr[u].r)
	{
		tr[u].mx = tr[u].sum = v;
		return ;
	}
	int mid = tr[u].l + tr[u].r >> 1;
	if(x <= mid)	update(ls, x, v);
	else	update(rs, x, v);
	pushup(u);
}

Node merge(Node &a, Node &b)
{
	return {a.l, b.r, max(a.mx, b.mx), a.sum + b.sum};
}

Node query(int u, int l, int r)
{
	if(l <= tr[u].l && tr[u].r <= r)	return tr[u];
	int mid = tr[u].l + tr[u].r >> 1;
	if(r <= mid)	return query(ls, l, r);
	else if(l > mid)	return query(rs, l, r);
	else
	{
		Node left = query(ls, l, r), right = query(rs, l, r);
		return merge(left, right);
	}
}

Node query_path(int u, int v)
{
	Node res = {0, 0, -INF, 0}, t;
	while(top[u] != top[v])
	{
		if(dep[top[u]] < dep[top[v]])	swap(u, v);
		t = query(1, id[top[u]], id[u]);
		res = merge(res, t);
		u = fa[top[u]];
	}
	if(dep[u] < dep[v])	swap(u, v);
	t = query(1, id[v], id[u]);
	return merge(res, t);
}

int main()
{
#ifdef LOCAL
	freopen("in.in", "r", stdin);
	freopen("out.out", "w", stdout);
#endif

	scanf("%d", &n);
	for(int i = 1; i < n; i ++)
	{
		int a, b;
		scanf("%d%d", &a, &b);
		add(a, b), add(b, a);
	}
	for(int i = 1; i <= n; i ++)	scanf("%d", &w[i]);

	dfs1(1, -1, 1);
	dfs2(1, 1);
	build(1, 1, n);

	scanf("%d", &m);
	while(m --)
	{
		char str[10];
		int u, v;
		scanf("%s%d%d", str, &u, &v);

		if(str[1] == 'H')	update(1, id[u], v);
		else
		{
			Node ans = query_path(u, v);
			printf("%d\n", str[1] == 'M' ? ans.mx : ans.sum);
		}
	}

	return 0;
}

P2146 [NOI2015] 软件包管理器

proudzhao
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
树链剖分（轻重链剖分）
zixiangzhan的博客
10-25 639
树链剖分（轻重链剖分） 简介 树链剖分，简称”树剖“，顾名思义，就是将树“解剖”，将其转化成可用线段树维护的形式。由于线段树仅能进行区间上的操作，故需要通过一种划分方式，使得树链转化成区间，再用线段树维护。而“轻重儿子”的划分方式，不仅将树链转化成区间，还保证了该算法的复杂度。该算法可以用小常数n*log2 (n)的时间复杂度，维护一颗形态固定的树的树上路径信息，如对一段路径上的点进行修改，询问一段路径上所有点的权值和等等。值得一提的是，该算法还顺便可以用于求出两点之间的LCA.复杂度也为log，并且求L
树链剖分模板题
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];...
树链剖分
weixin_30298497的博客
11-20 147
　　首先，在学树链剖分之前最好先把 LCA、树形DP、DFS序 这三个知识点学了还有必备的 链式前向星、线段树 也要先学了。如果这些个知识点没掌握好的话，树链剖分难以理解也是当然的 　　树链剖分 就是对一棵树分成几条链，把树形变为线性，减少处理难度需要处理的问题： 将树从x到y结点最短路径上所有节点的值都加上z 求树从x到y结点最短路径上所有节点的值之和 将以x为根节点的子树内所有节点...
树链剖分详解，看这一篇就够了
最新发布
Chat_lsm2024的博客
05-15 663
树链剖分详解，看这一篇就够了
*树链剖分
DCDCBigBig的博客
05-22 411
今天是2017/5/22，DCDCBigBig的第九篇博文 树链剖分（+线段树）//hdu3966 #include<algorithm> #include<iostream> #include<cstring> #include<cstdio> #include<cmath> #pragma comment(linker, "/STACK:1024000000,1024000000") using
树链剖分模板
08-08
第一遍dfs求出树每个结点的深度deep[x]，其为根的子树大小size[x] 以及祖先的信息fa[x][i]表示x往上距离为2^i的祖先 第二遍dfs 根节点为起点，向下拓展构建重链 选择最大的一个子树的根继承当前重链 其余节点，都...
NOIP树链剖分习题讲解报告
11-01
P2590 [ZJOI2008]树的统计 P3384 【模板】轻重链剖分/树链剖分 P3950 部落冲突 P4092 [HEOI2016/TJOI2016]树 P2146 [NOI2015] 软件包管理器
ACM模版终极版
11-20
ACM模版-->矩阵快速幂，搜索，树链剖分，线段树，动态规划，RMQ
SG打表与树链剖分详解
这篇文档主要涵盖了几个重要的图论和动态规划相关的算法，包括SG打表、树链剖分、树形DP、状态压缩DP以及数论公式的一些补充内容，如素数个数和最大团问题。以下是这些知识点的详细说明： 1. SG打表 (Stable ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值