算法自学——树链剖分

已于 2023-04-07 16:43:40 修改
阅读量498 收藏
点赞数 1
文章标签： 算法 深度优先 图论
于 2022-08-05 19:00:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MaTF_/article/details/126183557
版权

参考资料：

树链剖分的含义

树链剖分就是将一棵树划分成若干条链，并保证每一条链上的dfs序连续，从而利用线段树对树上的信息进行维护。

重链剖分

在这里插入图片描述

实现

  • fa[i]：结点i的父结点的编号。
  • siz[i]：以结点i为根的子树的结点数。
  • dep[i]：结点i的深度。
  • son[i]：结点i的所有子结点中，siz值最大的子结点的编号。
  • dfn[i]：结点i的dfs序。
  • top[i]：结点i所在链中，dep值最小的结点的编号。
  • rnk[i]：dfs序为i的结点的编号。

重链剖分就是要得到每个结点的上述信息，需要通过两个dfs来实现：

void dfs1(int x){	//得到fa、siz、dep、son
	siz[x] = 1;
	son[x] = 0;
	for(int i=head[x];i!=0;i=edge[i].next){
		int to = edge[i].to;
		if(to==fa[x]) continue;
		fa[to] = x;
		dep[to] = dep[x]+1;
		dfs1(to);
		siz[x] += siz[to];
		if(siz[to]>siz[son[x]]) son[x] = to;
	}
}

void dfs2(int x, int rt){	//得到dfn、top、rnk
	index++;
	dfn[x] = index;
	top[x] = rt;
	rnk[index] = x;
	if(son[x]!=0) dfs2(son[x], rt);
	for(int i=head[x];i!=0;i=edge[i].next){
		int to = edge[i].to;
		if(to==fa[x] || to==son[x]) continue;
		dfs2(to, to);
	}
}

路径上维护

注：代码中的modify()和query都是线段树的操作，返回值均为void。

void modify_tree1(int x, int y, int v){
	while(top[x]!=top[y]){
		if(dep[top[x]]<dep[top[y]]) swap(x, y);		//易错！
		modify(1, dfn[top[x]], dfn[x], v);
		x = fa[top[x]];
	}
	if(dep[x]<dep[y]) swap(x, y);
	modify(1, dfn[y], dfn[x], v);
}

int query_tree1(int x, int y){
	int res = 0;
	while(top[x]!=top[y]){	//直到两结点位于同一条链上为止
		if(dep[top[x]]<dep[top[y]]) swap(x, y);
		ans = 0;
		query(1, dfn[top[x]], dfn[x]);	//query()将结果保存在全局变量ans中
		res += ans;
		x = fa[top[x]];
	}
	if(dep[x]<dep[y]) swap(x, y);
	ans = 0;
	query(1, dfn[y], dfn[x]);
	res += ans;
	return res;
}

子树上维护

子树上的结点的dfs序是连续的。

void modify_tree2(int x, int v){
	modify(1, dfn[x], dfn[x]+siz[x]-1, v);
}

int query_tree2(int x){
	ans = 0;
	query(1, dfn[x], dfn[x]+siz[x]-1);
	return ans;
}

P3384 【模板】轻重链剖分/树链剖分

LCA

int LCA(int x, int y){
	while(top[x]!=top[y]){
		if(dep[top[x]]<dep[top[y]]) swap(x, y);
		x = fa[top[x]];
	}
	if(dep[x]<dep[y]) swap(x, y);
	return y;
}

例题：P3379 【模板】最近公共祖先（LCA）

例1 P2590 [ZJOI2008]树的统计

题目描述

一棵树上有 n n n 个节点，编号分别为 1 1 1 到 n n n，每个节点都有一个权值 w w w。

我们将以下面的形式来要求你对这棵树完成一些操作：

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 的路径上的节点的权值和。

注意：从点 u u u 到点 v v v 的路径上的节点包括 u u u 和 v v v 本身。

输入格式

输入文件的第一行为一个整数 n n n，表示节点的个数。

接下来 n − 1 n-1 n−1 行，每行 2 2 2 个整数 a a a 和 b b b，表示节点 a a a 和节点 b b b 之间有一条边相连。

接下来一行 n n n 个整数，第 i i i 个整数 w i w_i wi​ 表示节点 i i i 的权值。

接下来 1 1 1 行，为一个整数 q q q，表示操作的总数。

接下来 q q q 行，每行一个操作，以 CHANGE u t 或者 QMAX u v 或者 QSUM u v 的形式给出。

输出格式

对于每个 QMAX 或者 QSUM 的操作，每行输出一个整数表示要求输出的结果。

样例 #1

样例输入 #1

4
1 2
2 3
4 1
4 2 1 3
12
QMAX 3 4
QMAX 3 3
QMAX 3 2
QMAX 2 3
QSUM 3 4
QSUM 2 1
CHANGE 1 5
QMAX 3 4
CHANGE 3 6
QMAX 3 4
QMAX 2 4
QSUM 3 4

样例输出 #1

4
1
2
2
10
6
5
6
5
16

提示

对于 100 % 100 \% 100% 的数据，保证 1 ≤ n ≤ 3 × 1 0 4 1\le n \le 3\times 10^4 1≤n≤3×104， 0 ≤ q ≤ 2 × 1 0 5 0\le q\le 2\times 10^5 0≤q≤2×105。

中途操作中保证每个节点的权值 w w w 在 − 3 × 1 0 4 -3\times 10^4 −3×104 到 3 × 1 0 4 3\times 10^4 3×104 之间。

思路

本题为树剖路径上维护与查询的模板题。

代码

#include<bits/stdc++.h>
#define lc (i<<1)
#define rc (i<<1|1)
#define inf 0x7fffffff
using namespace std;

const int maxn = 3e4+5;

int n, q;
int a[maxn];

struct EDGE{
	int to;
	int next;
};

EDGE edge[maxn<<1];
int tot = 0;
int head[maxn];

void addEdge(int fr, int to){
	tot++;
	edge[tot].to = to;
	edge[tot].next = head[fr];
	head[fr] = tot;
}

int siz[maxn], dep[maxn], son[maxn], dfn[maxn], f[maxn], top[maxn], nfd[maxn];
int cnt = 0;

void dfs1(int x, int fa){
	siz[x] = 1;
	son[x] = 0;
	f[x] = fa;
	dep[x] = dep[fa]+1;
	for(int i=head[x];i!=0;i=edge[i].next){
		int to = edge[i].to;
		if(to == fa) continue;
		dfs1(to, x);
		siz[x] += siz[to];
		if(siz[to]>siz[son[x]]) son[x] = to;
	}
}

void dfs2(int x, int rt){
	cnt++;
	dfn[x] = cnt;
	nfd[cnt] = x;
	top[x] = rt;
	if(son[x] != 0) dfs2(son[x], rt);
	for(int i=head[x];i!=0;i=edge[i].next){
		int to = edge[i].to;
		if(to == f[x] || to == son[x]) continue;
		dfs2(to, to);
	}
}

struct TREE{
	int l, r;
	int M;
	int sum;
};

TREE tree[maxn<<2];

void pushUp(int i){
	tree[i].M = max(tree[lc].M, tree[rc].M);
	tree[i].sum = tree[lc].sum + tree[rc].sum;
}

void build(int i, int l, int r){
	tree[i].l = l, tree[i].r = r;
	if(l==r){
		tree[i].M = a[nfd[l]];		//易错
		tree[i].sum = a[nfd[l]];
		return;
	}
	int mid = (l+r)>>1;
	build(lc, l, mid);
	build(rc, mid+1, r);
	pushUp(i);
}

void modify(int i, int l, int r, int v){
	if(tree[i].l>=l&&tree[i].r<=r){
		tree[i].M = v;
		tree[i].sum = v;
	}
	else if(tree[i].r<l||tree[i].l>r){
		return;
	}
	else{
		modify(lc, l, r, v);
		modify(rc, l, r, v);
		pushUp(i);
	}
}

int ans = 0;

void queryMax(int i, int l, int r){
	if(tree[i].l>=l&&tree[i].r<=r){
		ans = max(ans, tree[i].M);
	}
	else if(tree[i].r<l||tree[i].l>r){
		return;
	}
	else{
		queryMax(lc, l, r);
		queryMax(rc, l, r);
	}
}

int queryMaxOnTree(int u, int v){
	int res = -inf;
	while(top[u]!=top[v]){
		if(dep[top[u]]<dep[top[v]]) swap(u, v);
		ans = -inf;
		queryMax(1, dfn[top[u]], dfn[u]);	//易错：链头的dfs序最小
		res = max(res, ans);
		u = f[top[u]];
	}
	if(dep[u]<dep[v]) swap(u, v);
	ans = -inf;
	queryMax(1, dfn[v], dfn[u]);
	res = max(res, ans);
	return res;
}

void querySum(int i, int l, int r){
	if(tree[i].l>=l&&tree[i].r<=r){
		ans += tree[i].sum;
	}
	else if(tree[i].r<l||tree[i].l>r){
		return;
	}
	else{
		querySum(lc, l, r);
		querySum(rc, l, r);
	}
}

int querySumOnTree(int u, int v){
	int res = 0;
	while(top[u]!=top[v]){
		if(dep[top[u]]<dep[top[v]]) swap(u, v);
		ans = 0;
		querySum(1, dfn[top[u]], dfn[u]);
		res += ans;
		u = f[top[u]];
	}
	if(dep[u]<dep[v]) swap(u, v);
	ans = 0;
	querySum(1, dfn[v], dfn[u]);
	res += ans;
	return res;
}

int main(){
	cin>>n;
	for(int i=1;i<n;i++){
		int u, v;
		cin>>u>>v;
		addEdge(u, v);
		addEdge(v, u);
	}
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	dfs1(1, 0);
	dfs2(1, 1);
	build(1, 1, n);
	cin>>q;
	for(int i=1;i<=q;i++){
		string cmd;
		int u, v;
		cin>>cmd>>u>>v;
		if(cmd[1]=='H') modify(1, dfn[u], dfn[u], v);
		else if(cmd[1]=='M') cout<<queryMaxOnTree(u, v)<<'\n';
		else cout<<querySumOnTree(u, v)<<'\n';
	}
	return 0;
}

例2 P4315 月下“毛景树”

题目背景

毛毛虫经过及时的变形，最终逃过的一劫，离开了菜妈的菜园。 毛毛虫经过千山万水，历尽千辛万苦，最后来到了小小的绍兴一中的校园里。

题目描述

爬啊爬爬啊爬毛毛虫爬到了一颗小小的“毛景树”下面，发现树上长着他最爱吃的毛毛果~~ “毛景树”上有 N N N 个节点和 N − 1 N-1 N−1 条树枝，但节点上是没有毛毛果的，毛毛果都是长在树枝上的。但是这棵“毛景树”有着神奇的魔力，他能改变树枝上毛毛果的个数：

  • Change k w：将第k条树枝上毛毛果的个数改变为 w w w 个。
  • Cover u v w：将节点 u u u 与节点 v v v 之间的树枝上毛毛果的个数都改变为 w w w 个。
  • Add u v w：将节点 u u u 与节点 v v v 之间的树枝上毛毛果的个数都增加 w w w 个。

由于毛毛虫很贪，于是他会有如下询问：

  • Max u v：询问节点 u u u 与节点 v v v 之间树枝上毛毛果个数最多有多少个。

输入格式

第一行一个正整数 N N N。

接下来 N − 1 N-1 N−1 行，每行三个正整数 U i , V i U_i,V_i Ui​,Vi​ 和 W i W_i Wi​，第 i + 1 i+1 i+1 行描述第 i i i 条树枝。表示第 i i i 条树枝连接节点 U i U_i Ui​ 和节点 V i V_i Vi​，树枝上有 W i W_i Wi​ 个毛毛果。 接下来是操作和询问，以 Stop 结束。

输出格式

对于毛毛虫的每个询问操作，输出一个答案。

样例 #1

样例输入 #1

4
1 2 8
1 3 7
3 4 9
Max 2 4
Cover 2 4 5
Add 1 4 10
Change 1 16
Max 2 4
Stop

样例输出 #1

9
16

提示

对于全部数据， 1 ≤ N ≤ 1 0 5 1\le N\le 10^5 1≤N≤105，操作和询问数目不超过 1 0 5 10^5 105。

保证在任意时刻，所有树枝上毛毛果的个数都不会超过 1 0 9 10^9 109 个。

思路

本题为树剖维护边权的模板题，还涉及到了线段树的染色+修改，需要注意的细节较多。

代码

#include<bits/stdc++.h>
#define int long long
#define lc (i<<1)
#define rc (i<<1|1)
using namespace std;

const int maxn = 1e5+5;

struct NODE{
	int fr, to;
	int v;
};
NODE node[maxn];

struct EDGE{
	int fr, to, v;
	int next;
};
EDGE edge[maxn<<1];

int head[maxn];
int tot = 0;

void addEdge(int fr, int to, int v){
	tot++;
	edge[tot].to = to;
	edge[tot].v = v;
	edge[tot].next = head[fr];
	head[fr] = tot;
}

struct TREE{
	int l, r;
	int m;
	int coverTag = -1;
	int addTag = 0;
};
TREE tree[maxn<<2];

int siz[maxn], fa[maxn], son[maxn], dep[maxn], dfn[maxn], top[maxn], ndf[maxn];
int a[maxn];	//用点权代替边权 
int cnt = 0;

void dfs1(int x, int f){
	siz[x] = 1;
	son[x] = 0;
	fa[x] = f;
	dep[x] = dep[f]+1;
	for(int i=head[x];i!=0;i=edge[i].next){
		int to = edge[i].to, v = edge[i].v;
		if(to==f) continue;
		a[to] = v;
		dfs1(to, x);
		siz[x] += siz[to];
		if(siz[to]>siz[son[x]]) son[x] = to; 
	}
}

void dfs2(int x, int rt){
	cnt++;
	dfn[x] = cnt;
	ndf[cnt] = x;
	top[x] = rt;
	if(son[x]!=0) dfs2(son[x], rt);
	for(int i=head[x];i!=0;i=edge[i].next){
		int to = edge[i].to;
		if(to==fa[x] || to==son[x]) continue;
		dfs2(to, to);
	}
}

void pushUp(int i){
	tree[i].m = max(tree[lc].m, tree[rc].m);
}

void pushDown(int i){		//注意pushdown顺序
	if(tree[i].coverTag!=-1){
		tree[lc].addTag = tree[rc].addTag = 0;
		tree[lc].m = tree[rc].m = tree[i].coverTag;
		tree[lc].coverTag = tree[rc].coverTag = tree[i].coverTag;
		tree[i].coverTag = -1;
	}
	if(tree[i].addTag!=0){
		tree[lc].addTag += tree[i].addTag;
		tree[lc].m += tree[i].addTag;
		tree[rc].addTag += tree[i].addTag;
		tree[rc].m += tree[i].addTag;
		tree[i].addTag = 0;
	}
} 

void build(int i, int l, int r){
	tree[i].l = l, tree[i].r = r;
	if(l==r){
		tree[i].m = a[ndf[l]];
		return;
	}
	int mid = (l+r)>>1;
	build(lc, l, mid);
	build(rc, mid+1, r);
	pushUp(i);	
}

void cover(int i, int l, int r, int v){
	if(tree[i].l>=l&&tree[i].r<=r){
		tree[i].coverTag = v;
		tree[i].addTag = 0;
		tree[i].m = v;
	}
	else if(tree[i].l>r||tree[i].r<l){
		return;
	}
	else{
		pushDown(i);
		cover(lc, l, r, v);
		cover(rc, l, r, v);
		pushUp(i);
	}
}

void add(int i, int l, int r, int v){
	if(tree[i].l>=l&&tree[i].r<=r){
		tree[i].addTag += v;
		tree[i].m += v;
	}
	else if(tree[i].l>r||tree[i].r<l){
		return;
	}
	else{
		pushDown(i);
		add(lc, l, r, v);
		add(rc, l, r, v);
		pushUp(i);
	}
} 

void modifyOnTree(int x, int y, int v, int cmd){	
	while(top[x]!=top[y]){
		if(dep[top[x]]<dep[top[y]]) swap(x, y);
		if(cmd==0) cover(1, dfn[top[x]], dfn[x], v);	//易错
		else add(1, dfn[top[x]], dfn[x], v);	
		x = fa[top[x]];
	}
	if(x==y) return;
	if(dep[x]<dep[y]) swap(x, y);
	if(cmd==0) cover(1, dfn[y]+1, dfn[x], v);		//易错
	else add(1, dfn[y]+1, dfn[x], v);	
} 

int ans = 0;

void query(int i, int l ,int r){
	if(tree[i].l>=l&&tree[i].r<=r){
		ans = max(ans, tree[i].m);
	}
	else if(tree[i].l>r||tree[i].r<l){
		return;
	}
	else{
		pushDown(i);
		query(lc, l, r);
		query(rc, l, r);
	}
}

int queryOnTree(int x, int y){
	int res = 0;
	while(top[x]!=top[y]){
		if(dep[top[x]]<dep[top[y]]) swap(x, y);
		ans = 0;
		query(1, dfn[top[x]], dfn[x]);
		res = max(res, ans);
		x = fa[top[x]];
	}
	if(x==y) return res;
	if(dep[x]<dep[y]) swap(x, y);
	ans = 0;
	query(1, dfn[y]+1, dfn[x]);
	res = max(res, ans);
	return res;	
} 

int n;

signed main(){
	cin>>n;
	for(int i=1;i<n;i++){
		int u, v, w;
		cin>>u>>v>>w;
		node[i].fr = u, node[i].to = v, node[i].v = w;
		addEdge(u, v, w);
		addEdge(v, u, w);
	} 
	dfs1(1, 0);
	dfs2(1, 1);
	build(1, 1, n);
	while(1){
		string cmd;
		int u, v, w;
		cin>>cmd;
		if(cmd[0]=='S') break;
		else if(cmd[0]=='M'){
			cin>>u>>v;
			cout<<queryOnTree(u, v)<<'\n';
		}
		else if(cmd[0]=='A'){
			cin>>u>>v>>w;
			modifyOnTree(u, v, w, 1);
		}
		else{
			if(cmd[1]=='o'){
				cin>>u>>v>>w;
				modifyOnTree(u, v, w, 0);
			}
			else{
				cin>>u>>v;
				modifyOnTree(node[u].fr, node[u].to, v, 0);
			}
		}
	}
	return 0;
}

例3 P1967 [NOIP2013 提高组] 货车运输

题目描述

A 国有 n n n 座城市，编号从 1 1 1 到 n n n，城市之间有 m m m 条双向道路。每一条道路对车辆都有重量限制，简称限重。

现在有 q q q 辆货车在运输货物， 司机们想知道每辆车在不超过车辆限重的情况下，最多能运多重的货物。

输入格式

第一行有两个用一个空格隔开的整数 $ n,m$，表示 A 国有 $ n$ 座城市和 m m m 条道路。

接下来 m m m 行每行三个整数 x , y , z x, y, z x,y,z，每两个整数之间用一个空格隔开，表示从 x x x 号城市到 y y y 号城市有一条限重为 z z z 的道路。
注意： x ≠ y x \neq y x=y，两座城市之间可能有多条道路 。

接下来一行有一个整数 q q q，表示有 q q q 辆货车需要运货。

接下来 q q q 行，每行两个整数 x , y x,y x,y，之间用一个空格隔开，表示一辆货车需要从 x x x 城市运输货物到 y y y 城市，保证 x ≠ y x \neq y x=y

输出格式

共有 q q q 行，每行一个整数，表示对于每一辆货车，它的最大载重是多少。
如果货车不能到达目的地，输出 − 1 -1 −1。

样例 #1

样例输入 #1

4 3
1 2 4
2 3 3
3 1 1
3
1 3
1 4
1 3

样例输出 #1

3
-1
3

提示

对于 100 % 100\% 100% 的数据， 1 ≤ n < 1 0 4 1 \le n < 10^4 1≤n<104， 1 ≤ m < 5 × 1 0 4 1 \le m < 5\times 10^4 1≤m<5×104， 1 ≤ q < 3 × 1 0 4 1 \le q< 3\times 10^4 1≤q<3×104， 0 ≤ z ≤ 1 0 5 0 \le z \le 10^5 0≤z≤105。

思路

首先使用 Kruskal 算法求出最大生成树，如果最后得到是一片森林，则在森林之间建立权值为-1的边，使之成为一棵树。然后利用树剖算法对最大生成树进行划分，并将边的权值保存在深度较大的点上。利用线段树维护区间最小值，即可得到正确答案。

代码

#include<bits/stdc++.h>
#define INF 0x7fffffff
#define lc (i<<1)
#define rc (i<<1|1)
using namespace std;

const int maxn = 1e4+5;
const int maxm = 5e4+5;
const int maxq = 3e4+5;

int n, m, q;
int x, y, z;

struct NODE{
	int x, y, z;
	bool operator<(const NODE& a)const{
		return z>a.z;	//sort默认升序排序
	}
}; 
NODE node[maxm];

struct EDGE{
	int to;
	int v;
	int next;
};
EDGE edge[maxm<<1];

int head[maxn];
int tot = 0;

void addEdge(int fr, int to, int v){
	tot++;
	edge[tot].to = to;
	edge[tot].v = v;
	edge[tot].next = head[fr];
	head[fr] = tot;
}

int fa[maxn], rnk[maxn];

void init(int n){
	for(int i=1;i<=n;i++){
		fa[i] = i;
		rnk[i] = 1;
	}
}

int find(int x){
	return (x==fa[x]) ? x : (fa[x]=find(fa[x]));
}

void merge(int x, int y){
	int X = find(x), Y = find(y);
	if(X==Y) return;
	if(rnk[X]>rnk[Y]) fa[Y] = X;
	else if(rnk[Y]>rnk[X]) fa[X] = Y;
	else{
		fa[Y] = X;
		rnk[X]++;
	}
}

bool flag[maxn];
vector<int> temp;

void buildTree(){
	for(int i=1;i<=m;i++){
		int fr=node[i].x, to=node[i].y, v=node[i].z;
		if(find(fr)!=find(to)){
			addEdge(fr, to, v);
			addEdge(to, fr, v);
			merge(fr, to);
		}
	}
	for(int i=1;i<=n;i++){
		int I = find(i);
		if(!flag[I]){
			temp.push_back(I);
			flag[I] = 1;
		}
	}
	for(int j=1;j<temp.size();j++){
		addEdge(temp[0], temp[j], -1);
		addEdge(temp[j], temp[0], -1);
//			merge(i, j);
	}
}

int siz[maxn], son[maxn], dep[maxn], dfn[maxn], f[maxn], top[maxn], value[maxn], nfd[maxn];
int idx = 0;

void dfs1(int x, int fa){
	f[x] = fa;
	dep[x] = dep[fa]+1;
	siz[x] = 1;
	son[x] = 0;
	for(int i=head[x];i!=0;i=edge[i].next){
		int to=edge[i].to, v=edge[i].v;
		if(to==fa) continue;
		dfs1(to, x);
		value[to] = v;		//将边权保存在深度较大的点上
		siz[x] += siz[to];
		if(siz[to]>siz[son[x]]) son[x] = to;
	}
}

void dfs2(int x, int rt){
	idx++;
	dfn[x] = idx;
	nfd[idx] = x;
	top[x] = rt;
	if(son[x]!=0) dfs2(son[x], rt);
	for(int i=head[x];i!=0;i=edge[i].next){
		int to=edge[i].to, v=edge[i].v;
		if(to==f[x] || to==son[x]) continue;
		dfs2(to, to);
	}
}

struct TREE{
	int l, r;
	int v;
};
TREE tree[maxn<<2];

void pushUp(int i){
	tree[i].v = min(tree[lc].v, tree[rc].v);
}

void build(int i, int l, int r){
	tree[i].l = l, tree[i].r = r;
	if(l==r){
		tree[i].v = value[nfd[l]];		//线段树中的l、r对应的是dfs序
		return;
	}
	int mid = (l+r)>>1;
	build(lc, l, mid);
	build(rc, mid+1, r);
	pushUp(i);
}

int ans = INF;

void query(int i, int l, int r){
	if(tree[i].l>=l&&tree[i].r<=r){
		ans = min(ans, tree[i].v);
	}
	else if(tree[i].l>r||tree[i].r<l) return;
	else{
		query(lc, l, r);
		query(rc, l, r);
	}
}

int queryTree(int x, int y){
	int rtn = INF;
	while(top[x]!=top[y]){
		if(dep[top[x]]<dep[top[y]]) swap(x, y);
		ans = INF;
		query(1, dfn[top[x]], dfn[x]);
		rtn = min(ans, rtn);
		x = f[top[x]];
	}	
	if(dep[x]<dep[y]) swap(x, y);
	ans = INF;
	query(1, dfn[y]+1, dfn[x]);
	rtn = min(ans, rtn);
	return rtn;
}

int main(){
	cin>>n>>m;
	for(int i=1;i<=m;i++){
		cin>>node[i].x>>node[i].y>>node[i].z;
	}
	sort(node+1, node+m+1);
	init(n);
	buildTree();
	value[1] = INF;
	dfs1(1, 0);
	dfs2(1, 1);
	build(1, 1, n);
	cin>>q;
	for(int i=1;i<=q;i++){
		int x, y;
		cin>>x>>y;
		if(find(x)!=find(y)) cout<<-1;
		else cout<<queryTree(x, y);
		cout<<'\n';
	}
	
	return 0;
}
MaTF_
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
学习记录day18——数据结构 算法
weixin_64918301的博客
07-24 693
程序 = 数据结构 + 算法算法是程序设计的灵魂，结构式程序设计的肉体算法：计算机解决问题的方法护额步骤。
算法训练营第47天|1143.最长公共子序列|1035.不相交的线|53. 最大子序和|392.判断子序列
bless_______的博客
07-24 290
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;未想到特殊情况，即s或t为空串的情况，因为返回的是数组值，但是如果是空串就不会建立数组。
树链剖分详解，看这一篇就够了
Chat_lsm2024的博客
05-15 661
树链剖分详解，看这一篇就够了
Codeforces Round 961 (Div. 2)
2301_80105412的博客
07-24 996
Codeforces Round 961 (Div. 2) ABC
【算法】字典序最小的 01 字符串
2301_79728896的博客
07-24 329
每次只能交换相邻的两个字符,从前向后遍历字符,如果遇到10组合的要交换,同时k–,注意交换后的情况是前面有可能会出现10组合,因此k>0时要回退,直到(用while)前面没有10组合或k==0为止。小红有一个 01 字符串，她可以进行最多 k 次提作，每次操作可以交换相邻的两个字符，问可以得到的字典序最小的字符串是什么。第一行包含两个整数，n（1 < n < 10^5）和 k（1 < k < 10^9），表示字符串的长度和可以进行的操作次数。输出一个长度为 n 的字符串，表示字典序最小的字符串。
2766. 重新放置石块 Medium
珞米的博客
07-24 545
第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，有石块的位置为 [2,2,3,3]。第 i = 1 步操作中，我们将位置 3 处的石块移到位置 2 处，有石块的位置为 [2,2,2,2]。第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，位置 2,6,7,8 有石块。第 i = 1 步操作中，我们将位置 7 处的石块移到位置 9 处，位置 2,6,8,9 有石块。第 i = 2 步操作中，我们将位置 2 处的石块移到位置 5 处，位置 5,6,8,9 有石块。
贪心加暴力枚举
wniuniu_的博客
07-24 282
所以我们可以直接暴力枚举，然后我们知道假操作一定是在最开始进行，至于加多少次我们可以直接枚举。
河南萌新联赛2024第（二）场：南阳理工学院
a13997460860的博客
07-25 1084
这场比赛里面出到了很多的题，都是需要很多的时间去写，主要考察到了代码的实现能力，与codeforces里面的题有些差距。codeforces打多了还是有点不习惯的。题挺好的，尤其是H题感觉很考代码实现能力与STL的使用熟练度。多写写这样的题还是对我们很有好处的。只不过前三题都太水了，没有一点难度。
137.只出现一次的数字Ⅱ
cqjnovo的博客
07-24 460
给你一个整数数组nums，除某个元素仅出现外，其余每个元素都恰出现请你找出并返回那个只出现了一次的元素。你必须设计并实现线性时间复杂度的算法且使用常数级空间来解决此问题。399。
小红书（社招二面）算法原题
最新发布
宫水三叶的刷题日记
07-25 982
但如果从百度（甚至是社会交通运输行业）的角度出发，萝卜快跑还是一个尚未全国铺开的产品，甚至还是一个内测产品，同时也代表了一个未来很有前景的行业，现如今却落入"抢人类饭碗"的社会问题舆论中，很容易就会导致整个行业被扼杀。从现在的环境分析，萝卜快跑的流量已经上来了，此时选择涨价到正常水平，可以进一步平衡订单的供求关系，又可以让舆论冷却，还能达成当时补贴是「为了拿到更多真实数据」的目的，是最符合经济原则的做法。首先，萝卜快跑的定价权是在百度手上的，萝卜快跑如今选择涨价，和网约车保持相当的水准。
【算法】浅析回溯算法
Young_Pro的博客
07-24 776
回溯算法是一种试探性的算法，它尝试通过分步的方式来解决问题。在解决一些组合问题（如八皇后、0-1背包问题等）和决策问题（如旅行商问题、图着色问题等）时，回溯算法是一种非常有力的工具。
算法：BFS解决 FloodFill 算法
一名还在努力学习技术的程序员的博客
07-24 1133
本篇博客是关于BFS 解决 FloodFill 算法的练习题，每道题都超链接了力扣的网页，每道题都有详细的解答过程
大话C语言：第33篇 数组指针
whccf的博客
07-25 357
数组指针是一个指针变量，其值是一个数组的首地址，即数组中第一个元素的地址。数组指针与指向单个元素的指针不同，它指向整个数组，并允许通过指针运算来访问数组中的各个元素。：在C语言中，二维数组在内存中是连续存储的，行与行之间紧密排列。通过数组指针，你可以方便地访问二维数组中的元素，而不需要使用嵌套循环。：当你想将一个数组作为参数传递给一个函数时，你通常会传递一个数组指针，而不是整个数组。数组指针的声明通常包括指针的类型和它所指向的数组的类型。其中，指向一维数组的数组指针，其中，指向二维数组的数组指针，
2024.7.24 作业
qq_64434282的博客
07-24 1816
【代码】2024.7.24 作业。
2024 暑假友谊赛-热身2
qq_42643660的博客
07-24 944
树的直径，N%m=N-(N/m)*m，期望dp..迷，简单线段树
打卡第22天------回溯算法
GodLoveMe的博客
07-24 576
开始学习了，希望我可以尽快成功上岸！
【CodinGame】趣味算法 CLASH OF CODE - 20240724
weixin_73002968的博客
07-24 309
eval不安全，看情况使用。
国科大作业考试资料《人工智能原理与算法》2024新编-第十三次作业整理
qq_51234298的博客
07-24 130
1、假设我们从决策树生成了一个训练集，然后将决策树学习应用于该训练集。当训练集的大小趋于无穷时，学习算法将最终返回正确的决策树吗？为什么是或不是？
【数据结构】排序算法——Lesson2
奋斗的小羊的博客
07-23 1757
归并、计数排序
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值