树链剖分【2023.1.31】

已于 2023-02-01 19:49:35 修改
阅读量76 收藏
点赞数
分类专栏： 树链剖分 文章标签： 数据结构 算法 深度优先
于 2023-01-31 21:27:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cqbzcypsy/article/details/128822957
版权

文章目录

一.引入

其实一个合理的引入对学生的兴趣影响很大

− c q b z g m \qquad \qquad \qquad \qquad \qquad \qquad \qquad \qquad -cqbzgm −cqbzgm

但是竞赛哪里有那么多兴趣 , 更重要的是恒心与毅 力    ( 虽然我没有   但是竞赛哪里有那么多兴趣,更重要的是恒心与毅力_{~~(虽然我没有~~} 但是竞赛哪里有那么多兴趣,更重要的是恒心与毅力  (虽然我没有  ​

二.算法介绍

树链剖分，顾名思义，指一种对树进行划分的算法，它先通过轻重边剖分将树分为多条链，保证每个点属于且只属于一条链，然后再通过数据结构（树状数组、BST、SPLAY、线段树等）来维护每一条链。

− 源于百度百科 \qquad \qquad \qquad \qquad \qquad \qquad \qquad \qquad -源于百度百科 −源于百度百科

三.实现

光写个概念是无用的,我们还得去想办法实现.

我们先引入一点东西:

重儿子:一个结点的所有儿子中,子树节点数最多的那个

轻儿子:一个结点除重儿子以外的其他儿子

重链:从一个轻儿子开始,一直往他的重儿子走出的链

轻链:除重链外的其他链

然后看这张图:

在这里插入图片描述

我们用黄色来标记重儿子和重链:
在这里插入图片描述

再按照优先遍历重链对结点重新编号:

在这里插入图片描述

然后你就会发现,我们完成了 d f s dfs dfs序.

根据以上的流程,我们就可以写 d f s dfs dfs序了.

代码:

/*
dfs1:找出所有结点之间的关系 并求得每个结点的重儿子
dfs2:对所有结点重新编号
id[u]:dfs序后的编号
tmp[cnt]:序号cnt对应结点u
fa[u]:u的父亲结点
d[u]:u的深度
size[u]:u为根节点的子树的结点个数
son[u]:u的重儿子
top[u]:u所在的重链顶端结点
*/
void dfs1(int u){
	size[u] = 1, d[u] = d[fa[u]] + 1;//这个点本身size=1,深度为他父亲+1
	for(int i = head[u]; i; i = g[i].next){
		int v = g[i].to;
		if(v == fa[u])continue;
		fa[v] = u;
		dfs1(v);
		size[u] += size[v];
		if(size[son[u]] < size[v])son[u] = v;//求重儿子
	}
}
void dfs2(int u, int front){
	top[u] = front, id[u] = ++ cnt, tmp[cnt] = u;
	if(son[u])dfs2(son[u], front);
	for(int i = head[u]; i; i = g[i].next){
		int v = g[i].to;
		if(v != fa[u] && v != son[u])dfs2(v, v);//一个点位于轻链底端,那么他的top必然是它本身
	}
}

然后我们就可以迎接例题了~~(终于写完了 h h h _{hhh} hhh​~~

四，例题

1.【模板】 P 3384 P3384 P3384重链剖分/树链剖分

P 3384 P3384 P3384

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 为根节点的子树内所有节点值之和

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
#define lson Tree[x].ls
#define rson Tree[x].rs
#define lz Tree[x].lazy
#define len(x) (Tree[x].r - Tree[x].l + 1)
struct edge{
	int next, to;
}g[MAXN << 1];
struct Segment_Tree{
	int l, r, ls, rs, sum, lazy;
}Tree[MAXN << 2];
int head[MAXN << 1], cnt;
int n, m, r, mod, a[MAXN], root;
int fa[MAXN], d[MAXN], son[MAXN], size[MAXN], top[MAXN], id[MAXN], tmp[MAXN];
void add(int u, int v){
	g[++ cnt] = (edge){head[u], v};
	head[u] = cnt;
}
void dfs1(int u){
	size[u] = 1, d[u] = d[fa[u]] + 1;
	for(int i = head[u]; i; i = g[i].next){
		int v = g[i].to;
		if(v == fa[u])continue;
		fa[v] = u;
		dfs1(v);
		size[u] += size[v];
		if(size[son[u]] < size[v])son[u] = v;
	}
}
void dfs2(int u, int front){
	top[u] = front, id[u] = ++ cnt, tmp[cnt] = u;
	if(son[u])dfs2(son[u], front);
	for(int i = head[u]; i; i = g[i].next){
		int v = g[i].to;
		if(v != fa[u] && v != son[u])dfs2(v, v);
	}
}
void pushup(int x){
	Tree[x].sum = (Tree[lson].sum + Tree[rson].sum) % mod;
}
void pushdown(int x){
	if(!lz)return ;
	Tree[lson].lazy += lz, Tree[lson].lazy %= mod;
	Tree[rson].lazy += lz, Tree[rson].lazy %= mod;
	Tree[lson].sum += lz * len(lson), Tree[lson].sum %= mod;
	Tree[rson].sum += lz * len(rson), Tree[rson].sum %= mod;
	lz = 0;
}
void build(int l, int r, int x){
	Tree[x].l = l, Tree[x].r = r;
  	if(l == r){
		Tree[x].sum = a[tmp[l]];
		return ;
	}
	int mid = l + r >> 1;
	lson = cnt ++, rson = cnt ++;
	build(l, mid, lson), build(mid + 1, r, rson);
	Tree[x].l = Tree[lson].l, Tree[x].r = Tree[rson].r;
	pushup(x);
}
void update(int l, int r, int k, int x){
	if(Tree[x].l >= l && Tree[x].r <= r){
		lz += k, lz %= mod;
		Tree[x].sum += len(x) * k, Tree[x].sum %= mod;
		return ;
	}
	pushdown(x);
	int mid = Tree[x].l + Tree[x].r >> 1;
	if(mid >= l)update(l, r, k, lson);
	if(mid < r)update(l, r, k, rson);
	pushup(x);
}
int query(int l, int r, int x){
	if(Tree[x].l >= l && Tree[x].r <= r)return Tree[x].sum;
	pushdown(x);
	int mid = Tree[x].l + Tree[x].r >> 1, sum = 0;
	if(mid >= l)sum += query(l, r, lson);
	if(mid < r)sum += query(l, r, rson);
	return sum % mod;
}
int sum(int l, int r){
	int res = 0;
	while(top[l] != top[r]){
		if(d[top[l]] < d[top[r]])swap(l, r);
		res += query(id[top[l]], id[l], root), res %= mod;
		l = fa[top[l]];
	}
	if(id[l] > id[r])swap(l, r);
	return (res + query(id[l], id[r], root)) % mod;
}
void updates(int l, int r, int x){
	while(top[l] != top[r]){
		if(d[top[l]] < d[top[r]])swap(l, r);
		update(id[top[l]], id[l], x, root);
		l = fa[top[l]];
	}
	if(id[l] > id[r])swap(l, r);
	update(id[l], id[r], x, root);
}
int main(){
	scanf("%d %d %d %d", &n, &m, &r, &mod);
	for(int i = 1; i <= n; i ++)scanf("%d", &a[i]);
	for(int i = 1; i < n; i ++){
		int u, v;
		scanf("%d %d", &u, &v);
		add(u, v), add(v, u);
	}
	cnt = 0, dfs1(r), dfs2(r, r);
	cnt = 0, build(1, n, root = cnt ++);
	for(int i = 1; i <= m; i ++){
		int opt, x, y, k;
		scanf("%d", &opt);
		if(opt == 1){
			scanf("%d %d %d", &x, &y, &k);
			updates(x, y, k);
		}
		else if(opt == 2){
			scanf("%d %d", &x, &y);
			printf("%d\n", sum(x, y));
		}
		else if(opt == 3){
			scanf("%d %d", &x, &y);
			update(id[x], id[x] + size[x] - 1, y, root);
		}
		else {
			scanf("%d", &x);
			printf("%d\n", query(id[x], id[x] + size[x] - 1, root));
		}
	}
	return 0;
}

2. P 2590 P2590 P2590树的统计

P 2590 P2590 P2590:

I. CHANGE u t : 把结点 u u u 的权值改为 t t t。
II. QMAX u v: 询问从点 u u u 到点 v v v 的路径上的节点的最大权值。
III. QSUM u v: 询问从点 u u u 到点 v v v 的路径上的节点的权值和。

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
#define lson pos << 1
#define rson pos << 1 | 1
struct edge{
	int next, to;
}g[MAXN << 1];
struct Segment_Tree{
	int l, r, sum, maxn;
	Segment_Tree(){
		l = r = sum = 0;
		maxn = -0x3f3f3f3f;
	}
}Tree[MAXN << 2];
int head[MAXN << 1], cnt;
int n, m, r, mod, a[MAXN];
int fa[MAXN], d[MAXN], son[MAXN], size[MAXN], top[MAXN], id[MAXN], tmp[MAXN], tot;
void add(int u, int v){
	g[++ cnt] = (edge){head[u], v};
	head[u] = cnt;
}
void dfs1(int u){
	size[u] = 1;
	for(int i = head[u]; i; i = g[i].next){
		int v = g[i].to;
		if(v == fa[u])continue;
		d[v] = d[u] + 1;
		fa[v] = u;
		dfs1(v);
		size[u] += size[v];
		if(size[son[u]] < size[v])son[u] = v;
	}
}
void dfs2(int u, int front){
	top[u] = front, id[u] = ++ tot, tmp[tot] = u;
	if(son[u])dfs2(son[u], front);
	for(int i = head[u]; i; i = g[i].next){
		int v = g[i].to;
		if(v != fa[u] && v != son[u])dfs2(v, v);
	}
}
void pushup(int pos){
	Tree[pos].sum = Tree[lson].sum + Tree[rson].sum;
	Tree[pos].maxn = max(Tree[lson].maxn, Tree[rson].maxn);
}
void build(int pos, int l, int r){
	Tree[pos].l = l, Tree[pos].r = r;
	if(l == r){
		Tree[pos].sum = Tree[pos].maxn = a[tmp[l]];
		return ;
	}
	int mid = l + r >> 1;
	build(lson, l, mid);
	build(rson, mid + 1, r);
	pushup(pos);
}
void update(int pos, int k, int x){
	if(Tree[pos].l == Tree[pos].r){
		Tree[pos].sum = Tree[pos].maxn = x;
		return ;
	}
	int mid = Tree[pos].l + Tree[pos].r >> 1;
	if(k <= mid)update(lson, k, x);
	else update(rson, k, x);
	pushup(pos);
}
int querymax(int pos, int ql, int qr){
	if(ql <= Tree[pos].l && Tree[pos].r <= qr)return Tree[pos].maxn;
	int mid = Tree[pos].l + Tree[pos].r >> 1, maxn = -0x3f3f3f3f;
	if(ql <= mid)maxn = max(maxn, querymax(lson, ql, qr));
	if(qr > mid) maxn = max(maxn, querymax(rson, ql, qr));
	return maxn;
}
int querysum(int pos, int l, int r, int ql, int qr){
	if(ql <= l && r <= qr)return Tree[pos].sum;
	int mid = l + r >> 1, sum = 0;
	if(ql <= mid)sum += querysum(lson, l, mid, ql, qr);
	if(qr > mid)sum += querysum(rson, mid + 1, r, ql, qr);
	return sum;
}
int getmax(int l, int r){
	int res = -0x3f3f3f3f;
	while(top[l] != top[r]){
		if(d[top[l]] < d[top[r]])swap(l, r);
		res = max(res, querymax(1, id[top[l]], id[l]));
		l = fa[top[l]];
	}
	if(d[l] > d[r])swap(l, r);
	return max(res, querymax(1, id[l], id[r]));
}
int getsum(int l, int r){
	int res = 0;
	while(top[l] != top[r]){
		if(d[top[l]] < d[top[r]])swap(l, r);
		res += querysum(1, 1, n, id[top[l]], id[l]);
		l = fa[top[l]];
	}
	if(d[l] > d[r])swap(l, r);
	return res + querysum(1, 1, n, id[l], id[r]);
}
int main(){
	scanf("%d", &n);
	for(int i = 1; i < n; i ++){
		int u, v;
		scanf("%d %d", &u, &v);
		add(u, v), add(v, u);
	}
	for(int i = 1; i <= n; i ++)scanf("%d", &a[i]);
	scanf("%d", &m);
	fa[1] = d[1] = 1;
	dfs1(1), dfs2(1, 1);
	build(1, 1, n);
	for(int i = 1; i <= m; i ++){
		string opt;
		int x, y;
		cin >> opt;
		if(opt == "CHANGE"){
			scanf("%d %d", &x, &y);
			update(1, id[x], y);
		}
		else if(opt == "QMAX"){
			scanf("%d %d", &x, &y);
			printf("%d\n", getmax(x, y));
		}
		else{
			scanf("%d %d", &x, &y);
			printf("%d\n", getsum(x, y));
		}
	}
	return 0;
}

3. P 3178 P3178 P3178树上操作

P3178

操作 1 1 1 ：把某个节点 x x x 的点权增加 a a a 。
操作 2 2 2 ：把某个节点 x x x 为根的子树中所有点的点权都增加 a 。
操作 3 3 3 ：询问某个节点 x x x 到根的路径中所有点的点权和。

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
#define lson pos << 1
#define rson pos << 1 | 1
#define len(x) (Tree[x].r - Tree[x].l + 1)
#define lz Tree[pos].lazy
#define int long long
struct edge{
	int next, to;
}g[MAXN << 1];
struct Segment_Tree{
	int l, r, ls, rs, sum, lazy;
	Segment_Tree(){
		l = r = sum = 0;
	}
}Tree[MAXN << 2];
int head[MAXN << 1], cnt;
int n, m, r, mod, a[MAXN];
int fa[MAXN], d[MAXN], son[MAXN], size[MAXN], top[MAXN], id[MAXN], tmp[MAXN], tot;
void add(int u, int v){
	g[++ cnt] = (edge){head[u], v};
	head[u] = cnt;
}
void dfs1(int u){
	size[u] = 1;
	for(int i = head[u]; i; i = g[i].next){
		int v = g[i].to;
		if(v == fa[u])continue;
		d[v] = d[u] + 1;
		fa[v] = u;
		dfs1(v);
		size[u] += size[v];
		if(size[son[u]] < size[v])son[u] = v;
	}
}
void dfs2(int u, int front){
	top[u] = front, id[u] = ++ tot, tmp[tot] = u;
	if(son[u])dfs2(son[u], front);
	for(int i = head[u]; i; i = g[i].next){
		int v = g[i].to;
		if(v != fa[u] && v != son[u])dfs2(v, v);
	}
}
void pushdown(int pos){
	if(!lz)return ;
	Tree[lson].lazy += lz;
	Tree[rson].lazy += lz;
	Tree[lson].sum += lz * len(lson);
	Tree[rson].sum += lz * len(rson);
	lz = 0;
}
void build(int pos, int l, int r){
	Tree[pos].l = l, Tree[pos].r = r;
	if(l == r){
		Tree[pos].sum = a[tmp[l]];
		return ;
	}
	int mid = l + r >> 1;
	build(lson, l, mid);
	build(rson, mid + 1, r);
	Tree[pos].sum = Tree[lson].sum + Tree[rson].sum;
}
void update(int pos, int k, int x){
	if(Tree[pos].l == Tree[pos].r){
		Tree[pos].sum += x;
		return ;
	}
	pushdown(pos);
	int mid = Tree[pos].l + Tree[pos].r >> 1;
	if(k <= mid)update(lson, k, x);
	else update(rson, k, x);
	Tree[pos].sum = Tree[lson].sum + Tree[rson].sum;
}
void update1(int l, int r, int k, int pos){
	if(Tree[pos].l >= l && Tree[pos].r <= r){
		lz += k;
		Tree[pos].sum += len(pos) * k;
		return ;
	}
	pushdown(pos);
	int mid = Tree[pos].l + Tree[pos].r >> 1;
	if(mid >= l)update1(l, r, k, lson);
	if(mid < r)update1(l, r, k, rson);
	Tree[pos].sum = Tree[lson].sum + Tree[rson].sum;
}
int querysum(int pos, int l, int r, int ql, int qr){
	if(ql <= l && r <= qr)return Tree[pos].sum;
	int mid = l + r >> 1, sum = 0;
	pushdown(pos);
	if(ql <= mid)sum += querysum(lson, l, mid, ql, qr);
	if(qr > mid)sum += querysum(rson, mid + 1, r, ql, qr);
	return sum;
}
int getsum(int l, int r){
	int res = 0;
	while(top[l] != top[r]){
		if(d[top[l]] < d[top[r]])swap(l, r);
		res += querysum(1, 1, n, id[top[l]], id[l]);
		l = fa[top[l]];
	}
	if(d[l] > d[r])swap(l, r);
	return res + querysum(1, 1, n, id[l], id[r]);
}
signed main(){
	scanf("%lld %lld", &n, &m);
	for(int i = 1; i <= n; i ++)scanf("%lld", &a[i]);
	for(int i = 1; i < n; i ++){
		int u, v;
		scanf("%lld %lld", &u, &v);
		add(u, v), add(v, u);
	}
	fa[1] = d[1] = 1;
	dfs1(1), dfs2(1, 1);
	build(1, 1, n);
	for(int i = 1; i <= m; i ++){
		int opt, x, y;
		scanf("%lld", &opt);
		if(opt == 1){
			scanf("%lld %lld", &x, &y);
			update(1, id[x], y);
		}
		else if(opt == 2){
			scanf("%lld %lld", &x, &y);
			update1(id[x], id[x] + size[x] - 1, y, 1);
		}
		else{
			scanf("%lld", &x);
			printf("%lld\n", getsum(1, x));
		}
	}
	return 0;
}

4. P 2146 [ N O I 2015 ] P2146 [NOI2015] P2146[NOI2015] 软件包管理器

P2146

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
#define lson pos << 1
#define rson pos << 1 | 1
#define len(x) (Tree[x].r - Tree[x].l + 1)
#define lz Tree[pos].lazy
struct edge{
	int next, to;
}g[MAXN << 1];
struct Segment_Tree{
	int l, r, sum, lazy;
	Segment_Tree(){
		l = r = sum = 0;
		lazy = -1;
	}
}Tree[MAXN << 2];
int head[MAXN << 1], cnt;
int n, m, a[MAXN];
int fa[MAXN], d[MAXN], son[MAXN], size[MAXN], top[MAXN], id[MAXN], tmp[MAXN], tot;
void add(int u, int v){
	g[++ cnt] = (edge){head[u], v};
	head[u] = cnt;
}
void dfs1(int u){
	size[u] = 1;
	for(int i = head[u]; i; i = g[i].next){
		int v = g[i].to;
		if(v == fa[u])continue;
		d[v] = d[u] + 1;
		fa[v] = u;
		dfs1(v);
		size[u] += size[v];
		if(size[son[u]] < size[v])son[u] = v;
	}
}
void dfs2(int u, int front){
	top[u] = front, id[u] = ++ tot, tmp[tot] = u;
	if(son[u])dfs2(son[u], front);
	for(int i = head[u]; i; i = g[i].next){
		int v = g[i].to;
		if(v != fa[u] && v != son[u])dfs2(v, v);
	}
}
void pushup(int pos){
	Tree[pos].sum = Tree[lson].sum + Tree[rson].sum;
}
void pushdown(int pos){
	if(lz == -1)return ;
	Tree[lson].lazy = Tree[rson].lazy = lz;
	Tree[lson].sum = lz * len(lson);
	Tree[rson].sum = lz * len(rson);
	lz = -1;
}
void build(int pos, int l, int r){
	Tree[pos].l = l, Tree[pos].r = r;
	if(l == r){
		Tree[pos].sum = 0;
		return ;
	}
	int mid = l + r >> 1;
	build(lson, l, mid);
	build(rson, mid + 1, r);
	pushup(pos);
}
void update(int l, int r, int k, int pos){
	if(Tree[pos].l >= l && Tree[pos].r <= r){
		lz = k;
		Tree[pos].sum = len(pos) * k;
		return ;
	}
	pushdown(pos);
	int mid = Tree[pos].l + Tree[pos].r >> 1;
	if(mid >= l)update(l, r, k, lson);
	if(mid < r)update(l, r, k, rson);
	Tree[pos].sum = Tree[lson].sum + Tree[rson].sum;
}
void change(int l, int r, int x){
	while(top[l] != top[r]){
		if(d[top[l]] < d[top[r]])swap(l, r);
		update(id[top[l]], id[l], x, 1);
		l = fa[top[l]];
	}
	if(d[l] > d[r])swap(l, r);
	update(id[l], id[r], x, 1);
}
int main(){
	scanf("%d", &n);
	for(int i = 2; i <= n; i ++){
		int v;
		scanf("%d", &v);
		v ++;
		add(i, v), add(v, i);
	}
	scanf("%d", &m);
	fa[1] = d[1] = 1;
	dfs1(1), dfs2(1, 1);
	build(1, 1, n);
	for(int i = 1; i <= m; i ++){
		string opt;
		int x;
		cin >> opt >> x;
		x ++;
		int tot = Tree[1].sum;
		if(opt == "install"){
			change(1, x, 1);
			printf("%d\n", abs(Tree[1].sum - tot));
		}
		else{
			update(id[x], id[x] + size[x] - 1, 0, 1);
			printf("%d\n", abs(Tree[1].sum - tot));
		}
	}
	return 0;
}

5. P 4092 [ H E O I 2016 / T J O I 2016 ] P4092 [HEOI2016/TJOI2016] P4092[HEOI2016/TJOI2016]树

P4092

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
#define lson pos << 1
#define rson pos << 1 | 1
struct edge{
	int next, to;
}g[MAXN << 1];
struct Segment_Tree{
	int l, r, deep;
	Segment_Tree(){
		l = r = 0;
		deep = -0x3f3f3f3f;
	}
}Tree[MAXN << 2];
int head[MAXN << 1], cnt;
int n, m, a[MAXN];
int fa[MAXN], d[MAXN], son[MAXN], size[MAXN], top[MAXN], id[MAXN], tmp[MAXN], tot;
void add(int u, int v){
	g[++ cnt] = (edge){head[u], v};
	head[u] = cnt;
}
void dfs1(int u){
	size[u] = 1;
	for(int i = head[u]; i; i = g[i].next){
		int v = g[i].to;
		if(v == fa[u])continue;
		d[v] = d[u] + 1;
		fa[v] = u;
		dfs1(v);
		size[u] += size[v];
		if(size[son[u]] < size[v])son[u] = v;
	}
}
void dfs2(int u, int front){
	top[u] = front, id[u] = ++ tot, tmp[tot] = u;
	if(son[u])dfs2(son[u], front);
	for(int i = head[u]; i; i = g[i].next){
		int v = g[i].to;
		if(v != fa[u] && v != son[u])dfs2(v, v);
	}
}
void pushup(int pos){
	Tree[pos].deep = max(Tree[lson].deep, Tree[rson].deep);
}
void build(int pos, int l, int r){
	Tree[pos].l = l, Tree[pos].r = r;
	if(l == r)return ;
	int mid = l + r >> 1;
	build(lson, l, mid);
	build(rson, mid + 1, r);
}
void update(int l, int r, int pos){
	if(Tree[pos].l >= l && Tree[pos].r <= r){
		Tree[pos].deep = l;
		return ;
	}
	int mid = Tree[pos].l + Tree[pos].r >> 1;
	if(mid >= l)update(l, r, lson);
	if(mid < r)update(l, r, rson);
	pushup(pos);
}
int query(int pos, int ql, int qr){
	if(ql <= Tree[pos].l && Tree[pos].r <= qr)return Tree[pos].deep;
	int mid = Tree[pos].l + Tree[pos].r >> 1, maxn = -0x3f3f3f3f;
	if(ql <= mid)maxn = max(maxn, query(lson, ql, qr));
	if(qr > mid) maxn = max(maxn, query(rson, ql, qr));
	return maxn;
}
int getmax(int l, int r){
	int res = -0x3f3f3f3f;
	while(top[l] != top[r]){
		if(d[top[l]] < d[top[r]])swap(l, r);
		res = max(res, query(1, id[top[l]], id[l]));
		if(res != -0x3f3f3f3f)return tmp[res];
		l = fa[top[l]];
	}
	if(d[l] > d[r])swap(l, r);
	return tmp[query(1, id[l], id[r])];
}
int main(){
	scanf("%d %d", &n, &m);
	for(int i = 1; i < n; i ++){
		int u, v;
		scanf("%d %d", &u, &v);
		add(u, v), add(v, u);
	}
	fa[1] = d[1] = 1;
	dfs1(1), dfs2(1, 1);
	build(1, 1, n);
	update(1, 1, 1);
	for(int i = 1; i <= m; i ++){
		char opt;
		int x;
		cin >> opt >> x;
		if(opt == 'C')update(id[x], id[x], 1);
		else printf("%d\n", getmax(x, 1));
	}
	return 0;
}

6. P 4315 P4315 P4315 月下“毛景树”

P4315

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
#define lson pos << 1
#define rson pos << 1 | 1
#define len(x) (Tree[x].r - Tree[x].l + 1)
#define lz Tree[pos].lazy
#define tg Tree[pos].tag
#define int long long
struct edge{
	int next, to, w;
}g[MAXN << 1];
struct Segment_Tree{
	int l, r, maxn, lazy, tag;
	Segment_Tree(){
		l = r = maxn = lazy = 0;
	}
}Tree[MAXN << 2];
int head[MAXN << 1], cnt;
int n, m, r, mod, a[MAXN], b[MAXN];
int fa[MAXN], d[MAXN], son[MAXN], size[MAXN], top[MAXN], id[MAXN], tmp[MAXN], tot;
template<typename T>
void read(T &x){
	x = 0;
	T f = 1;
	char ch = getchar();
	while(ch > '9' || ch < '0'){
		if(ch == '-')f = -1;
		ch = getchar();
	}
	while(ch >= '0' && ch <= '9'){
		x = (x << 1) + (x << 3) + (ch ^ 48);
		ch = getchar();
	}
	x *= f;
}
template<typename T>
void write(T x){
	if(x < 0){
		x = -x;
		putchar('-');
	}
	if(x >= 10)write(x / 10);
	putchar(x % 10 + 48);
}
void add(int u, int v, int w){
	g[++ cnt] = (edge){head[u], v, w};
	head[u] = cnt;
}
void dfs1(int u){
	size[u] = 1;
	for(int i = head[u]; i; i = g[i].next){
		int v = g[i].to;
		if(v == fa[u])continue;
		a[v] = g[i].w;
		d[v] = d[u] + 1;
		fa[v] = u;
		dfs1(v);
		size[u] += size[v];
		if(size[son[u]] < size[v])son[u] = v;
	}
}
void dfs2(int u, int front){
	top[u] = front, id[u] = ++ tot, tmp[tot] = u;
	if(son[u])dfs2(son[u], front);
	for(int i = head[u]; i; i = g[i].next){
		int v = g[i].to;
		if(v != fa[u] && v != son[u])dfs2(v, v);
	}
}
void pushup(int pos){
	Tree[pos].maxn = max(Tree[lson].maxn, Tree[rson].maxn);
}
void pushdown(int pos){
	if(lz >= 0){
		Tree[lson].tag = Tree[rson].tag = 0;
		Tree[lson].lazy = Tree[rson].lazy = Tree[lson].maxn = Tree[rson].maxn = lz;
		lz = -1;	
	}
	if(tg){
		Tree[lson].tag += tg, Tree[rson].tag += tg;
		Tree[lson].maxn += tg, Tree[rson].maxn += tg;
		tg = 0;
	}
}
void build(int pos, int l, int r){
	Tree[pos].l = l, Tree[pos].r = r, Tree[pos].lazy = -1;
	if(l == r){
		Tree[pos].maxn = a[tmp[l]];
		return ;
	}
	int mid = (l + r) >> 1;
	build(lson, l, mid);
	build(rson, mid + 1, r);
	pushup(pos);
}
void update(int pos, int k, int x){
	if(Tree[pos].l == Tree[pos].r){
		Tree[pos].maxn = lz = x;
		tg = 0;
		return ;
	}
	pushdown(pos);
	int mid = (Tree[pos].l + Tree[pos].r) >> 1;
	if(k <= mid)update(lson, k, x);
	else update(rson, k, x);
	pushup(pos);
}
void update1(int l, int r, int k, int pos){
	if(Tree[pos].l >= l && Tree[pos].r <= r){
		tg += k;
		Tree[pos].maxn += k;
		return ;
	}
	pushdown(pos);
	int mid = (Tree[pos].l + Tree[pos].r) >> 1;
	if(mid >= l)update1(l, r, k, lson);
	if(mid < r)update1(l, r, k, rson);
	pushup(pos);
}
void updates1(int l, int r, int x){
	while(top[l] != top[r]){
		if(d[top[l]] < d[top[r]])swap(l, r);
		update1(id[top[l]], id[l], x, 1);
		l = fa[top[l]];
	}
	if(d[l] > d[r])swap(l, r);
	update1(id[l] + 1, id[r], x, 1);
}
void update2(int l, int r, int k, int pos){
	if(Tree[pos].l >= l && Tree[pos].r <= r){
		lz = Tree[pos].maxn = k;
		tg = 0;
		return ;
	}
	pushdown(pos);
	int mid = (Tree[pos].l + Tree[pos].r) >> 1;
	if(mid >= l)update2(l, r, k, lson);
	if(mid < r)update2(l, r, k, rson);
	pushup(pos);
}
void updates(int l, int r, int x){
	while(top[l] != top[r]){
		if(d[top[l]] < d[top[r]])swap(l, r);
		update2(id[top[l]], id[l], x, 1);
		l = fa[top[l]];
	}
	if(d[l] > d[r])swap(l, r);
	update2(id[l] + 1, id[r], x, 1);
}
int query(int pos, int l, int r, int ql, int qr){
	if(ql <= l && r <= qr)return Tree[pos].maxn;
	int mid = (l + r) >> 1, maxn = -0x3f3f3f3f;
	pushdown(pos);
	if(ql <= mid)maxn = max(maxn, query(lson, l, mid, ql, qr));
	if(qr > mid)maxn = max(maxn, query(rson, mid + 1, r, ql, qr));
	return maxn;
}
int getmax(int l, int r){
	int res = -0x3f3f3f3f;
	while(top[l] != top[r]){
		if(d[top[l]] < d[top[r]])swap(l, r);
		res = max(res, query(1, 1, n, id[top[l]], id[l]));
		l = fa[top[l]];
	}
	if(d[l] > d[r])swap(l, r);
	return max(res, query(1, 1, n, id[l] + 1, id[r]));
	return res;
}
int u[MAXN], v[MAXN], w[MAXN];
signed main(){
	read(n);
	for(int i = 1; i < n; i ++){
		read(u[i]), read(v[i]), read(w[i]);
		add(u[i], v[i], w[i]), add(v[i], u[i], w[i]);
	}
	fa[1] = d[1] = 1;
	dfs1(1), dfs2(1, 1);
	build(1, 1, n);
	for(int i = 1; i < n; i ++){
		if(fa[u[i]] == v[i]) son[i] = u[i];
		else son[i] = v[i];
	}
	string opt;
	while(1){
		cin >> opt;
		if(opt == "Stop")break;
		int x, y, k;
		if(opt == "Change"){
			read(x), read(y);
			update(1, id[son[x]], y);
		}
		else if(opt == "Cover"){
			read(x), read(y), read(k);
			updates(x, y, k);
		}
		else if(opt == "Add"){
			read(x), read(y), read(k);
			updates1(x, y, k);
		}
		else{
			read(x), read(y);
			write(getmax(x, y));
			putchar('\n');
		}
	}
	return 0;
}

7. P 1505 P1505 P1505 [国家集训队]旅游

P1505

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
#define lson pos << 1
#define rson pos << 1 | 1
#define lz Tree[pos].lazy
#define int long long
struct edge{
	int next, to, w;
}g[MAXN << 1];
struct Segment_Tree{
	int l, r, maxn, minn, sum, lazy;
	Segment_Tree(){
		l = r = lazy = 0;
		maxn = -0x3f3f3f3f;
		minn = 0x3f3f3f3f;
	}
}Tree[MAXN << 2];
int head[MAXN << 1], cnt;
int n, m, r, mod, a[MAXN], b[MAXN];
int fa[MAXN], d[MAXN], son[MAXN], size[MAXN], top[MAXN], id[MAXN], tmp[MAXN], tot;
template<typename T>
void read(T &x){
	x = 0;
	T f = 1;
	char ch = getchar();
	while(ch > '9' || ch < '0'){
		if(ch == '-')f = -1;
		ch = getchar();
	}
	while(ch >= '0' && ch <= '9'){
		x = (x << 1) + (x << 3) + (ch ^ 48);
		ch = getchar();
	}
	x *= f;
}
template<typename T>
void write(T x){
	if(x < 0){
		x = -x;
		putchar('-');
	}
	if(x >= 10)write(x / 10);
	putchar(x % 10 + 48);
}
void add(int u, int v, int w){
	g[++ cnt] = (edge){head[u], v, w};
	head[u] = cnt;
}
void dfs1(int u){
	size[u] = 1;
	for(int i = head[u]; i; i = g[i].next){
		int v = g[i].to;
		if(v == fa[u])continue;
		a[v] = g[i].w;
		d[v] = d[u] + 1;
		fa[v] = u;
		dfs1(v);
		size[u] += size[v];
		if(size[son[u]] < size[v])son[u] = v;
	}
}
void dfs2(int u, int front){
	top[u] = front, id[u] = ++ tot, tmp[tot] = u;
	if(son[u])dfs2(son[u], front);
	for(int i = head[u]; i; i = g[i].next){
		int v = g[i].to;
		if(v != fa[u] && v != son[u])dfs2(v, v);
	}
}
void pushup(int pos){
	Tree[pos].maxn = max(Tree[lson].maxn, Tree[rson].maxn);
	Tree[pos].minn = min(Tree[lson].minn, Tree[rson].minn);
	Tree[pos].sum = Tree[lson].sum + Tree[rson].sum;
}
void pushdown(int pos){
	if(!lz)return ;
	Tree[lson].lazy ^= 1, Tree[rson].lazy ^= 1;
	Tree[lson].sum = -Tree[lson].sum, Tree[rson].sum = -Tree[rson].sum;
	Tree[lson].maxn = -Tree[lson].maxn, Tree[rson].maxn = -Tree[rson].maxn;
	Tree[lson].minn = -Tree[lson].minn, Tree[rson].minn = -Tree[rson].minn;
	swap(Tree[lson].maxn, Tree[lson].minn);
	swap(Tree[rson].maxn, Tree[rson].minn);
	lz = 0;
}
void build(int pos, int l, int r){
	Tree[pos].l = l, Tree[pos].r = r;
	if(l == r){
		Tree[pos].minn = Tree[pos].sum = Tree[pos].maxn = a[tmp[l]];
		return ;
	}
	int mid = (l + r) >> 1;
	build(lson, l, mid);
	build(rson, mid + 1, r);
	pushup(pos);
}
void update(int pos, int k, int x){
	if(Tree[pos].l == Tree[pos].r){
		Tree[pos].maxn = Tree[pos].minn = Tree[pos].sum = x;
		return ;
	}
	pushdown(pos);
	int mid = (Tree[pos].l + Tree[pos].r) >> 1;
	if(k <= mid)update(lson, k, x);
	else update(rson, k, x);
	pushup(pos);
}
void update1(int l, int r, int pos){
	if(Tree[pos].l >= l && Tree[pos].r <= r){
		lz ^= 1;
		Tree[pos].sum = -Tree[pos].sum, Tree[pos].maxn = -Tree[pos].maxn, Tree[pos].minn = -Tree[pos].minn;
		swap(Tree[pos].maxn, Tree[pos].minn);
		return ;
	}
	pushdown(pos);
	int mid = (Tree[pos].l + Tree[pos].r) >> 1;
	if(mid >= l)update1(l, r, lson);
	if(mid < r)update1(l, r, rson);
	pushup(pos);
}
void updates(int l, int r){
	while(top[l] != top[r]){
		if(d[top[l]] < d[top[r]])swap(l, r);
		update1(id[top[l]], id[l], 1);
		l = fa[top[l]];
	}
	if(d[l] > d[r])swap(l, r);	
	update1(id[l] + 1, id[r], 1);
}
int querymax(int pos, int ql, int qr){
	if(ql <= Tree[pos].l && Tree[pos].r <= qr)return Tree[pos].maxn;
	int mid = (Tree[pos].l + Tree[pos].r) >> 1, maxn = -0x3f3f3f3f;
	pushdown(pos);
	if(ql <= mid)maxn = max(maxn, querymax(lson, ql, qr));
	if(qr > mid)maxn = max(maxn, querymax(rson, ql, qr));
	pushup(pos);
	return maxn;
}
int querymin(int pos, int ql, int qr){
	if(ql <= Tree[pos].l && Tree[pos].r <= qr)return Tree[pos].minn;
	int mid = (Tree[pos].l + Tree[pos].r) >> 1, minn = 0x3f3f3f3f;
	pushdown(pos);
	if(ql <= mid)minn = min(minn, querymin(lson, ql, qr));
	if(qr > mid)minn = min(minn, querymin(rson, ql, qr));
	pushup(pos);
	return minn;
}
int querysum(int pos, int ql, int qr){
	if(ql <= Tree[pos].l && Tree[pos].r <= qr)return Tree[pos].sum;
	int mid = (Tree[pos].l + Tree[pos].r) >> 1, sum = 0;
	pushdown(pos);
	if(ql <= mid)sum += querysum(lson, ql, qr);
	if(qr > mid)sum += querysum(rson, ql, qr);
	pushup(pos);
	return sum;
}
int getmax(int l, int r){
	int res = -0x3f3f3f3f;
	while(top[l] != top[r]){
		if(d[top[l]] < d[top[r]])swap(l, r);
		res = max(res, querymax(1, id[top[l]], id[l]));
		l = fa[top[l]];
	}
	if(d[l] > d[r])swap(l, r);
	return max(res, querymax(1, id[l] + 1, id[r]));
}
int getmin(int l, int r){
	int res = 0x3f3f3f3f;
	while(top[l] != top[r]){
		if(d[top[l]] < d[top[r]])swap(l, r);
		res = min(res, querymin(1, id[top[l]], id[l]));
		l = fa[top[l]];
	}
	if(d[l] > d[r])swap(l, r);
	return min(res, querymin(1, id[l] + 1, id[r]));
}
int getsum(int l, int r){
	int res = 0;
	while(top[l] != top[r]){
		if(d[top[l]] < d[top[r]])swap(l, r);
		res += querysum(1, id[top[l]], id[l]);
		l = fa[top[l]];
	}
	if(d[l] > d[r])swap(l, r);
	return (res + querysum(1, id[l] + 1, id[r]));
}
int u[MAXN], v[MAXN], w[MAXN];
signed main(){
	read(n);
	for(int i = 1; i < n; i ++){
		read(u[i]), read(v[i]), read(w[i]);
		u[i] ++, v[i] ++;
		add(u[i], v[i], w[i]), add(v[i], u[i], w[i]);
	}
	fa[1] = d[1] = 1;
	dfs1(1), dfs2(1, 1);
	build(1, 1, n);
	for(int i = 1; i < n; i ++){
		if(fa[u[i]] == v[i]) son[i] = u[i];
		else son[i] = v[i];
	}
	read(m);
	string opt;
	while(m --){
		cin >> opt;
		int x, y;
		read(x), read(y);
		if(opt == "C"){
			update(1, id[son[x]], y);
		}
		else if(opt == "N"){
			updates(x + 1, y + 1);
		}
		else if(opt == "SUM"){
			write(getsum(x + 1, y + 1));
			putchar('\n');
		}
		else if(opt == "MAX"){
			write(getmax(x + 1, y + 1));
			putchar('\n');
		}
		else{
			write(getmin(x + 1, y + 1));
			putchar('\n');			
		}
	}
	return 0;
}
cqbzpsy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【树上莫队C++】Count on Tree II（欧拉序降维，树链剖分求最近共同祖先LCA）
qq_73928885的博客
09-22 311
像 `树` 这种二维的如果可以进行降维（将树转化成链处理）处理的话，也可以使用 `莫队算法` 处理。
树链剖分算法.pptx
09-03
树链剖分，计算机术语，指一种对树进行划分的算法，它先通过轻重边剖分将树分为多条链，保证每个点属于且只属于一条链，然后再通过数据结构（树状数组、BST、SPLAY、线段树等）来维护每一条链
2023.1.13模拟赛总结
zswangziye的博客
01-14 588
经典树剖，修改路径上的点，统计子树总和（此处注意子树节点实质上编号是在一起的，可以线段树区间修改）。直接建一棵区间为1~m的线段树，每插入一点就将该点值修改，维护区间最大值。，我们就可以减去这些情况，得到最终的结果。经典操作，维护区间最大连续子段和，单点修改。的情况没减掉，且这些情况的最大公约数为。区间翻转，区间修改，区间最大值查询。这样，我们就把问题转化为了求在现在的。虽然是莫反题，但是递推是可以搞的。但这之中还有些最大公约数不为。个数，使得最大公约数刚好为。：莫比乌斯反演、递推；的倍数个数，容易得到。
【YBT2023寒假Day14 C】字符串题（SAM）（树链剖分）（线段树）
欢迎您的光顾awa
02-24 556
对于一个字符串 S 定义 F(S) 是 fail 树上除了 0 点其它点的深度和。 G(S) 是 S 每个子串 S' 的 F(S') 之和。 然后一个空串，每次在后面加一个字符，要你维护这个串的 G 值。
每日一练2023.4.17-2023.4.18
weixin_54010759的博客
04-18 562
手写队列，队列有两个指针-front和rear，对于这两个指针，操作都是+1就是上移，如果需要构造循环队列，则需要进行取余对队列长度queueLength进行操作，队列为空等价于front不等于rear，即队首队尾指针不同，稍微整理代码如下，也可能不是，不是的话，利用该队头元素扩展与该节点有边相连且没有被访问的节点，将新的节点入队 ，直到队为空，所有图中相连的节点都被访问过。它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。
树链剖分习题.pptx
01-30
关于树链剖分cabzoj上面的题解
第5章 树链剖分 测试数据.rar
12-02
树链剖分是一种高效处理树型结构的算法，尤其在解决与树的边查询和修改有关的问题时，它能提供显著的效率提升。这一技术在信息学奥赛中经常被用到，帮助参赛者快速解决复杂的树形问题。在本章的测试数据中，你将有...
树链剖分.pptx
09-15
树链剖分
树链剖分大杂烩.cpp
09-15
树链剖分大杂烩
c语言（7.23）
fhgfyrsg的博客
07-23 385
【代码】c语言（7.23）
数据结构---二叉树
weixin_47808575的博客
07-22 328
参考：二叉树遍历方法——前、中、后序遍历（图解）_二叉树遍历前序中序后序-CSDN博客
重生之“我打数据结构，真的假的？”--3.栈和队列
2301_80374809的博客
07-21 763
栈：一种特殊的线性表，其只允许在进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守LIFO（Last In First Out）的原则。
【数据结构-前缀和】力扣2550.统计范围内的元音字符串数
sjsjs11的博客
07-22 508
计算前缀和数组的时间是 O(n)，然后计算 q 个查询的答案，计算每个查询的答案的时间是 O(1)，因此时间复杂度是 O(n+q)。输入：words = [“aba”,“bcb”,“ece”,“aa”,“e”], queries = [[0,2],[1,4],[1,1]]输入：words = [“a”,“e”,“i”], queries = [[0,2],[0,1],[2,2]]查询 [1,4] 结果为 3（字符串 “ece”、“aa”、“e”）。返回结果 [2,3,0]。输出：[3,2,1]
数据结构：（1）线性表
最新发布
weixin_71751116的博客
07-24 1018
概念：零个或多个数据元素的有限序列元素之间是有顺序了。如果存在多个元素，第一个元素无前驱最后一个没有后继其他的元素只有一个前驱和一个后继。当线性表元素的个数n（n>=0）定义为线性表的长度，当n=0时，为空表。在非空的表中每个元素都有一个确定的位置，如果a1是第一个元素，那么an就是第n个元素。线性表的常规操作 ADTchar sex;int age;int score;}DATATYPE;//数组名int tlen;
数据结构之判断完全二叉树详解与示例（C，C++）
qq_35320456的博客
07-23 374
通过上述C和C++的实现示例，我们可以看到判断一个二叉树是否为完全二叉树的基本方法是使用层序遍历。在遍历过程中，我们通过设置一个标记来区分节点是否应该为叶子节点，从而判断二叉树是否满足完全二叉树的条件。这种方法的时间复杂度为O(n)，其中n是二叉树中节点的数量，因为每个节点最多只会被访问一次。在实际应用中，完全二叉树由于其特殊的结构，常用于堆的实现，因为它可以在数组中有效地表示，同时保持堆的操作效率。理解并掌握判断完全二叉树的方法，对于深入理解二叉树结构和相关算法有重要意义。
数据结构（特殊二叉树－线索二叉树）
weixin_65029285的博客
07-22 358
链式二叉树中有很多的空指针，可以让这些空指针指向前一个节点\后一个节点，从而在有序遍历（中序遍历）二叉树时，不需要使用递归而通过循环即可以完成，并且效率要比递归快得多。首先需要有一颗搜索二叉树，然后通过中序遍历并生成线索，通过检查右子树是否为空来决定是否生成线索，让右子树指向下一个节点。bool lflag;// 左子树是否是线索 为真时，左子树是线索 指向前一个节点。bool rflag;// 右子树是否是线索 为真时，右子树是线索 指向下一个节点。
华清数据结构day5 24-7-22
m0_62859255的博客
07-22 380
【代码】华清数据结构day5 24-7-22。
数据结构（1）（顺序表）
qq_54094530的博客
07-23 821
数据结构相互之间存在一种或多种特定关系的数据元素的集合。逻辑结构集合，所有数据在同一个集合中，关系平等。（数组中的每一个int）线性，数据和数据之间是一对一的关系（队列，链表，数组（线性表的一种体现））树， 一对多（高效）图，多对多物理结构(在内存当中的存储关系)顺序存储，数据存放在连续的存储单位中。逻辑关系和物理关系一致链式，数据存放的存储单位是随机或任意的，可以连续也可以不连续。struct Per 数据元素char name;//数据项（变量）
NOIP树链剖分详解与实现
1. 剖分目的：树链剖分的目的是为了高效地处理树结构中的路径信息，通过将树转化为链状结构，便于快速访问和更新路径上的节点。 2. 轻边与重边：在树链剖分中，边被分为两类——轻边和重边。假设U是V的父亲节点，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值