算法笔记-Kruskal重构树

最新推荐文章于 2023-07-28 13:41:36 发布
最新推荐文章于 2023-07-28 13:41:36 发布
阅读量327 收藏
点赞数 3
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53899788/article/details/127410738
版权

Kruskal重构树

在Kruskal算法求最小生成树时，按照边权排序，然后依次合并节点。

在构建Kruskal重构树时，按照边权排序，在合并节点 x , y x,y x,y时，断开 x , y x,y x,y之间的边，并新建节点 z z z， z z z的点权为边 ( x , y ) (x,y) (x,y)的权值， z z z向 x , y x,y x,y分别连边，并用并查集维护连通性。

性质
  • 是二叉树
  • 如果按最小生成树顺序的话是大根堆
  • 原图上任意两点路径上边权的最大值是重构树上 l c a lca lca的点权
代码
void Kruskal(){
	sort(edg+1, edg+1+m, cmp);
	memset(e, 0, sizeof(e));
	memset(head, 0, sizeof(head));
	tot = 0;
	for(int i = 1; i <= n; i++)
		f[i] = i;
	nodetot = n;
	for(int i = 1; i <= m; i++){
		int fx = find(edg[i].x);
		int fy = find(edg[i].y);
		if(fx == fy)
			continue;
		val[++nodetot] = edg[i].v;
		f[nodetot] = f[fx] = f[fy] = nodetot;
		add(nodetot, fx); add(nodetot, fy);
	}
}


P4768 [NOI2018] 归程

题意：

给定一个连通图，边有两个权值，长度 l l l，高度 h h h。每次询问给定起点 s 0 s_0 s0​，水位线 h 0 h_0 h0​，高度小于等于 h 0 h_0 h0​的边只能走路，不能开车。终点为 1 1 1号结点，询问从 s 0 s_0 s0​到终点走路的最小长度。

解析：

将所有边按照高度排序，构建 k r u s k a l kruskal kruskal重构树，得到的是小根堆。对于一棵子树 u u u，如果水位线 h 0 h_0 h0​小于子树根节点的权值，该子树中的叶子结点是可以互相到达的，即原图中对应的点可以开车直达。

对于当前询问 ( s 0 , h 0 ) (s_0,h_0) (s0​,h0​)，找到根节点 u u u，满足 w [ u ] > h 0 w[u] > h_0 w[u]>h0​ 且 w [ f a [ u ] ] ≤ h 0 w[fa[u]] \le h_0 w[fa[u]]≤h0​，则 s 0 s_0 s0​可以开车到达的结点为子树 u u u的叶子结点。

可以利用 D i j s k r a Dijskra Dijskra求出所有点到 1 1 1号结点的最短路。按照高度排序，构建 k r u s k a l kruskal kruskal重构树，然后 d f s dfs dfs求出子树 u u u中到 1 1 1号结点路径的最小值 d [ u ] d[u] d[u]。

对于每次询问 ( s 0 , h 0 ) (s_0,h_0) (s0​,h0​)，利用倍增找到结点 u u u，答案为 d [ u ] d[u] d[u]

代码：
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
#define mkp(a, b) make_pair(a, b)
#define fi first
#define se second
const int maxn = 2e5+10;
const int maxm = 4e5+10;
const int INF = 0x3f3f3f3f;
struct edge{
	int to, nxt;
	ll v;//长度
}e[maxm<<1];
int head[maxn<<1], tot;
void add(int a, int b, ll c = 0){
	e[++tot].nxt = head[a];
	e[tot].to = b;
	e[tot].v = c;
	head[a] = tot;
}
struct node{
	int x, y, v;
	bool operator < (const node &b) const{
		return v > b.v;
	}
}edg[maxm];
int f[maxn<<1];
int find(int x){
	return x == f[x] ? x : f[x] = find(f[x]);
}
int nodetot;
int val[maxn<<1];
int n, m;
void Kruskal(){
	memset(e, 0, sizeof(e));
	memset(head, 0, sizeof(head));
	tot = 0;
	for(int i = 1; i <= n; i++)
		f[i] = i;
	nodetot = n;
	for(int i = 1; i <= m; i++){
		int fx = find(edg[i].x);
		int fy = find(edg[i].y);
		if(fx == fy)
			continue;
		val[++nodetot] = edg[i].v;
		f[nodetot] = f[fx] = f[fy] = nodetot;
		add(nodetot, fx); add(nodetot, fy);
	}
}
int vis[maxn];
ll dis[maxn<<1];
priority_queue<pll> q;
void Dijkstra(int s = 1){
	memset(vis, 0, sizeof(vis));
	memset(dis, INF, sizeof(dis));
	dis[1] = 0;
	q.push(mkp(0, 1));
	while(q.size()){
		int u = q.top().se; q.pop();
		if(vis[u])
			continue;
		vis[u] = 1;
		for(int i = head[u]; i; i = e[i].nxt){
			int v = e[i].to;
			if(dis[v] > dis[u]+e[i].v){
				dis[v] = dis[u]+e[i].v;
				q.push(mkp(-dis[v], v));
			}
		}
	}
}
int p[maxn<<1][20];
ll d[maxn<<1];
void dfs(int u, int fath){
	p[u][0] = fath;
	d[u] = dis[u];
	for(int i = 1; i <= 19; i++)
		p[u][i] = p[p[u][i-1]][i-1];
	for(int i = head[u]; i; i = e[i].nxt){
		int v = e[i].to;
		dfs(v, u);
		d[u] = min(d[u], d[v]);
	}
}
int find_node(int u, int x){
	int v = u;
	for(int i = 19; i >= 0; i--)
		if(val[p[v][i]] > x)
			v = p[v][i];
	return v;
}
int Q, K, S;
void init(){
	memset(head, 0, sizeof(head));
	tot = 0;
	memset(e, 0, sizeof(e));
	memset(p, 0, sizeof(p));
	memset(val, 0, sizeof(val));
	while(q.size())
		q.pop();
}
void solve(){
	cin >> n >> m;
	init();
	for(int i = 1; i <= m; i++){
		int x, y, v, h;
		cin >> x >> y >> v >> h;
		edg[i].x = x; edg[i].y = y; edg[i].v = h;
		add(x, y, v); add(y, x, v);
	}
	Dijkstra();
	sort(edg+1, edg+1+m);
	Kruskal();
	d[0] = -1;
	dfs(nodetot, 0);
	cin >> Q >> K >> S;
	ll last = 0;
	while(Q--){
		int v0, p0, v, p;
		cin >> v0 >> p0;
		v = (v0+K*last-1)%n+1;
		p = (p0+K*last)%(S+1);
		int x = find_node(v, p);
		last = d[x];
		//cout << "ans = ";
		cout << last << endl;
	}
}
int main(){
	int T;
	cin >> T;
	while(T--)
		solve();
	return 0;
}


P4197 Peaks

题意：

给定无向图，点有点权 h i h_i hi​，边有边权 x i x_i xi​。每次询问 ( v , x , k ) (v,x,k) (v,x,k)，从 v v v出发，只经过边权小于 x x x的边，能够到达的点中点权第 k k k大的点权。

解析：

只经过边权小于 x x x的边可以想到 K r u s k a l Kruskal Kruskal重构树，对于询问点权第 k k k大的点权可以想到主席树。

K r u s k a l Kruskal Kruskal重构树上非叶子结点"管辖"的叶子结点是一段连续的区间，在 d f s dfs dfs的时候，维护每个结点"管辖"的叶子结点区间。

对于询问 ( v , x , k ) (v,x,k) (v,x,k)，与上题类似，利用倍增找到结点 u u u，在 u u u管辖的区间中，查询区间第 k k k大。注意离散化

代码：
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 2e5+10;
const int maxm = 5e5+10;
const int INF = 0x3f3f3f3f;
int n, m, q;
int h[maxn];
struct node{ //原图上边 
	int x, y, z;
	bool operator < (const node &b)const{
		return z < b.z;
	}
}edg[maxm];
struct edge{ //重构树上边 
	int to, nxt;
}e[maxn];
int head[maxn], tot;
void add(int a, int b){
	e[++tot].nxt = head[a];
	e[tot].to = b;
	head[a] = tot;
}
struct discreteH{ //高度离散化 
	int h, id;
	bool operator < (const discreteH &b) const{
		return h < b.h;
	}
}dish[maxn];
int fa[maxn];
int val[maxn<<2]; //重构树上点权 
int find(int x){
	return x == fa[x] ? x : fa[x] = find(fa[x]);
}
int nodetot;
void Kruskal(){
	for(int i = 1; i <= n; i++)
		fa[i] = i;
	nodetot = n;
	for(int i = 1; i <= m; i++){
		int fx = find(edg[i].x);
		int fy = find(edg[i].y);
		if(fx == fy)
			continue;
		val[++nodetot] = edg[i].z;
		fa[nodetot] = fa[fx] = fa[fy] = nodetot;
		add(nodetot, fx); add(nodetot, fy);
	}
}
int L[maxn], R[maxn], p[maxn][20], b[maxn];
int dfstot;
void dfs(int u, int fath){
	p[u][0] = fath;
	for(int i = 1; i <= 19; i++)
		p[u][i] = p[p[u][i-1]][i-1];
	L[u] = dfstot;
	if(head[u] == 0){ //叶子即原图上的点 
		b[++dfstot] = u;
		R[u] = dfstot;
		return;
	}
	for(int i = head[u]; i; i = e[i].nxt){
		dfs(e[i].to, u);
	}
	R[u] = dfstot;
}
int roottot;
struct tree{
	int l, r, val;
}t[maxn*40];
int root[maxn];
void pushup(int rt){
	t[rt].val = t[t[rt].l].val + t[t[rt].r].val;
}
void build(int &rt, int l, int r){
	rt = ++roottot;
	if(l == r)
		return;
	int mid = (l+r) >> 1;
	build(t[rt].l, l, mid);
	build(t[rt].r, mid+1, r);
}
void modify(int &rt, int pre, int l, int r, int pos){
	rt = ++roottot;
	t[rt] = t[pre];
	if(l == r){
		t[rt].val ++;
		return;
	}
	int mid = (l+r) >> 1;
	if(pos <= mid)
		modify(t[rt].l, t[pre].l, l, mid, pos);
	else
		modify(t[rt].r, t[pre].r, mid+1, r, pos);
	pushup(rt);
	return;
}
int find_node(int u, int x){
	int v = u;
	for(int i = 19; i >= 0; i--)
		if(val[p[v][i]] <= x)
			v = p[v][i];
	return v;
}
int query(int rt1, int rt2, int l, int r, int k){
	if(l == r){
		if(k == (t[rt1].val - t[rt2].val))
			return l;
		else
			return 0;
	}
	int mid = (l+r) >> 1;
	int d = t[t[rt1].r].val - t[t[rt2].r].val;
	if(k <= d)
		return query(t[rt1].r, t[rt2].r, mid+1, r, k);
	else
		return query(t[rt1].l, t[rt2].l, l, mid, k-d);
}
int main(){
	cin >> n >> m >> q;
	for(int i = 1; i <= n; i++){
		cin >> dish[i].h;
		dish[i].id = i;;
	}
	sort(dish+1, dish+n+1);
	h[0] = INF;
	for(int i = 1; i <= n; i++)
		h[dish[i].id] = i; 
	for(int i = 1; i <= m; i++)
		cin >> edg[i].x >> edg[i].y >> edg[i].z;
	sort(edg+1, edg+1+m);
	Kruskal();
	dfs(nodetot, nodetot);
	build(root[0], 1, n);
	for(int i = 1; i <= dfstot; i++)
		modify(root[i], root[i-1], 1, n, h[b[i]]);
	dish[0].h = -1;
	for(int i = 1; i <= q; i++){
		int v, x, k;
		cin >> v >> x >> k;
		int ance = find_node(v, x);
		int ans = query(root[R[ance]], root[L[ance]], 1, n, k);
		cout << dish[ans].h << endl;
	}
	return 0;
}
hydqiln
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
kruskal重构树
qq_43041641的博客
04-13 248
kruskal重构树建立在kruskal最小生成树算法上，假设在做kruskal最小生成树时将要加边xyz(x,y,z)xyz，即连接结点xxx与结点yyy，边权为zzz，则建立一个新的点，分别连向xxx和yyy，点权为zzz，同时将该点设置为xxx与yyy的代表结点（很熟悉对不对？其实就是并查集！以此类推，直至做出最小生成树。
【学习笔记】kruskal 重构树
vectorwyx的博客
01-04 394
写这篇博客主要是因为oi-wiki上写得太精简了……我对着这几段话弄了一晚上才搞明白/kk 前置知识：最小生成树，与 kruskal 算法 在进行 kruskal 算法时，我们会将当前边的两个端点 xxx 和 yyy 所在的树合并成一棵，即连一条由 xxx 的树根指向 yyy 的树根的边，写成代码就是f[xx]=yy（假设 xxxxxx 和 yyyyyy 分别为 xxx 和 yyy 对应的根结点）。而 kruskal 重构树则是在合并时引入一个新的结点 nodnodnod，用 nodnodnod 作为 x
Kruskal重构树详解
m0_61735576的博客
05-16 5321
这棵树有很多独特的性质 就比如我们想知道从节点2到7路径的最大边权是多少，其实就是他们公共祖先这个虚点的点权值 再比如我们想知道从某个点出发，给出一个值，在通过所有边的权值都小于等于这个值时，我们走过多少个点，其实就等于这个点一直往上面找，找到最后一个小于等于这个值的虚点，他的子树的点我们都是可以通过的（因为从上到下点权不上升） 以上这种问题我们都可以通过在重构树上倍增的方式，把时间复杂度压到logn
Kruskal 重构树
m0_59092234的博客
03-15 2074
Kruskal 重构树 kruskal 最小生成树算法相信大家已经很熟悉了，所以这里就不介绍了。顾名思义 kruskal 重构树就是根据 kruskal 改造一下衍生出来的算法。它能解决下面这样的一个问题： 给定 n n n 个点 m m m 条边的无向图，每条边有一个边权为 d i d_i di。现在有 k k k 个询问，每次查询两点 x , y x, y x,y 之间的所有路径中，最长的边的最小值是多少。（ 1 ≤ n ≤ 15000 , 1 ≤ m ≤ 30000 , d i ≤ 1 e 9 , k
算法笔记-066Kruskal算法详解（Java）共10页
10-31
【Kruskal算法详解】 Kruskal算法是图论中的一种最小生成树算法，由Edsger W....同时，这本“算法笔记_066Kruskal算法详解”提供了详细的步骤和示例，对于学习者来说是一份宝贵的参考资料，可以深入学习和研究。
gkgammatst:Goodman-Kruskal 的伽马检验。-matlab开发
05-30
它是由 Leo Goodman 和 William Kruskal 在一系列论文（1954、1959、1963 和 1972）中提出的。 如果在一个变量上较高的受试者在另一个变量上也较高，则一对观察是一致的，如果在一个变量上较高的受试者在另一个...
论文研究 - Kruskal算法的研究与改进
06-01
本文讨论了Kruskal算法的基本思想，然后提出了一种新的改进算法-两分支Kruskal算法，该算法经过改进以选择中间值。 最后，由于减少了时间复杂度，并且处理更加方便，因此可以得出结论，改进的Kruskal算法在大多数...
算法笔记-上机训练实战指南-胡凡
07-27
包括但不限于排序算法（如冒泡排序、快速排序、归并排序、堆排序等）、搜索算法（如二分查找、深度优先搜索、广度优先搜索等）、图论算法（如最短路径算法Dijkstra、最小生成树Prim和Kruskal等）以及动态规划等。...
matlab-Kruskal算法求最小生成树问题.zip
最新发布
10-21
Kruskal算法是一种求解加权无向图的最小生成树的经典算法，由Joseph B. Kruskal于1956年提出。在MATLAB环境中实现Kruskal算法，可以方便地解决这类问题。下面我们将详细探讨Kruskal算法的基本思想、步骤以及MATLAB...
Kruskal重构树入门
mygrn的博客
07-28 188
Kruskal算法是一种求图上最小生成树的算法具体流程是：1.将图上所有边按边权由小到大排序2.每次取出一条边，若边的两个端点未被连接，则新增一条边3.重复操作2，直至图上所有点联通。
acm-Kruskal重构树学习笔记
qq_30361651的博客
09-30 404
引言 Kruskal重构树主要用于解决在线查询问题，询问通常涉及的条件为边权小于某值。 原理 考虑利用Kruskal算法构建一个最小生成树，但在此过程中稍稍改动一下。Kruskal算法的过程主要是按照边权由小到大的顺序对边上的两点做合并操作。现在假设正在处理u−v\mathbf{u-v}u−v这条边，Kruskal重构树将不会直接在新图建立边u−v\mathbf{u-v}u−v，而是建立一个新的节点t\mathbf{t}t，然后让该节点连向u和v\mathbf{u和v}u和v各自连通块的根节点，并给t\
最小生成树------克鲁斯卡尔(Kruskal)算法
moqisaonianqiong的博客
04-21 1688
克鲁斯卡尔(Kruskal)算法 1、基本介绍 它是一种将无向权重图构造成最小生成树（指的是树权重sum最小）的一种算法，基本思路是： 首先将图中的边按照权重升序排列得到一组有序数列[ [ i，j，w]，…， [ ] ]，例如以上就是按照w的升序排列得到的图G（V，E）的边列表，其中i，j分别代表这条边所连接的两个node节点，w表示这条边的权重值。 设待完成的生成树表示为T（U，TE） 之后利用循环迭代各条边[ i，j，w]，如果这条边的两个顶点属于T的两个不同的连通分量，则将此边作为最小生成树的边加入
克鲁斯卡尔算法(Kruskal)
sanqima的专栏
10-05 1975
克鲁斯卡尔(Kruskal)算法是一种按权值的递增次序选择合适的边来构造最小生成树的方法。假设G=(V,E)G=(V,E)是一个具有nn个顶点的带权连通图，T=(U,TE)T=(U,TE)是G的最小生成树，则构造最小生成树的步骤如下： 　　1) 设置UU的初值等于VV(即包含有GG中的全部顶点)， TETE的初值为空集(即图TT中每一个顶点都构成一个分量)。 　　2) 将图GG中的边按权值从小
Kruskal重构树—简介与基本应用
A_Bright_CH的博客
10-28 468
Kruskal重构树就是在做kruskal是把边权改成点权，一个n个点的图可以生成2*n-1个点的kruskal重构树。 一篇很棒的博客https://blog.csdn.net/hwzzyr/article/details/81190442 构造 维护一个并查集。把图上的边按边权值递增排序，每次取出最小的边，用并查集判断其两端的点是否已相连。如果是，那么直接略过这条边；否则，建一个新点r，点...
Kruskal重构树学习笔记（C++）
m0_74036684的博客
01-16 492
Kruskal重构树学习笔记
Kruskal算法、Kruskal重构树、LCA算法
qq_61786525的博客
05-09 995
KruskalKruskalKruskal 算法是一种求解最小生成树的贪心算法。它的基本思想是从图中的边集中依次选取边，使得选出的边不会构成回路，并且满足边权和最小。具体实现过程如下：将原图中的所有边按照边权从小到大排序。依次选取排序后的边，如果这条边的两个端点不在同一个连通块中，则加入该边，将它们之间的连通块合并成一个新的连通块，并把该边加入最小生成树的边集中。重复上述步骤，直至加入 n−1n−1n−1 条边（其中 nnn 表示原图的节点数），此时得到的边集即为原图的最小生成树。KruskalKruska
最小生成树-kruskal算法 抽象形态
05-15
最小生成树-Kruskal算法是一种计算无向图最小生成树的方法。其抽象形态是通过建立边的规则来构建最小生成树。算法首先将每个顶点看作一个独立的子树，然后将边按权重从小到大进行排序。依次考虑每一条边，若这条边...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值