克鲁斯卡尔重构树

最新推荐文章于 2023-07-12 07:07:51 发布
最新推荐文章于 2023-07-12 07:07:51 发布
阅读量244 收藏
点赞数 2
分类专栏： 图论 文章标签： 图论 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52383696/article/details/121653864
版权

克鲁斯卡尔重构树

用途

用来维护图上两点， u u u到 v v v的路径中，最大边权的最小值（或最小边权的最大值）

实现

像克鲁斯卡尔一样，先把边权排序，然后用并查集 建出一颗重构树，点权就是当前边的边权，然后再用树链剖分dfs两次，方便之后求 l c a lca lca；
如果原图不是连通图，那么建出的就是重构森林，以每个连通块最后加入的点为根；如果原图是连通图，那么最后加入的节点，就是重构树的根。

代码

void work(){
	cnt=n;
	for(int i=1;i<=n;i++)ff[i]=i;
	sort(z+1,z+1+m,cmp);
	for(int i=1;i<=m;i++){
		int a=find(z[i].x);
		int b=find(z[i].y);
		if(a==b)continue;
		val[++cnt]=z[i].w;
		ff[cnt]=ff[a]=ff[b]=cnt;
		v[cnt].push_back(a);
		v[cnt].push_back(b);
		v[a].push_back(cnt);
		v[b].push_back(cnt);
	}
	for(int i=1;i<=cnt;i++){
		if(vis[i])continue;
		int a=find(i);
		dfs1(a,0);dfs2(a,0);
	}
	/*
	//如果图是联通的，那么只需要从最后一个点开始处理即可
	dfs1(cnt,0);dfs2(cnt,0); 
	*/
}

例题

DarkOJ 3732

#include<bits/stdc++.h>
using namespace std;
#define ll long long 

int n,m,q;
struct node{
	int x,y,w;
}z[30040];
bool cmp(node a,node b){
	return a.w<b.w;
}
int ff[30050],fa[30050],siz[30050],son[30050],dep[30050],top[30050];
int val[30050],vis[30050],cnt;
vector<int>v[30050];
int find(int x){
	if(x==ff[x])return x;
	return ff[x]=find(ff[x]);
}
void dfs1(int x,int pre){
	fa[x]=pre;dep[x]=dep[pre]+1;
	siz[x]=1;vis[x]=1;
	for(int i=0;i<v[x].size();i++){
		int to=v[x][i];
		if(to==pre)continue;
		dfs1(to,x);
		siz[x]+=siz[to];
		if(siz[to]>siz[son[x]])son[x]=to;
	}
}
void dfs2(int x,int pre){
	if(son[pre]==x)top[x]=top[pre];
	else top[x]=x;
	if(son[x])dfs2(son[x],x);
	for(int i=0;i<v[x].size();i++){
		int to=v[x][i];
		if(to==pre||to==son[x])continue;
		dfs2(to,x);
	}
}
void work(){
	cnt=n;
	for(int i=1;i<=n;i++)ff[i]=i;
	sort(z+1,z+1+m,cmp);
	for(int i=1;i<=m;i++){
		int a=find(z[i].x);
		int b=find(z[i].y);
		if(a==b)continue;
		val[++cnt]=z[i].w;
		ff[cnt]=ff[a]=ff[b]=cnt;
		v[cnt].push_back(a);
		v[cnt].push_back(b);
		v[a].push_back(cnt);
		v[b].push_back(cnt);
	}
	for(int i=1;i<=cnt;i++){
		if(vis[i])continue;
		int a=find(i);
		dfs1(a,0);dfs2(a,0);
	}
}
int lca(int x,int y){
	while(top[x]!=top[y]){
		if(dep[top[x]]>dep[top[y]])swap(x,y);
		y=fa[top[y]];
	}
	if(dep[x]>dep[y])swap(x,y);
	return x;
}
int main(){
	scanf("%d%d%d",&n,&m,&q);
	for(int i=1;i<=m;i++){
		scanf("%d%d%d",&z[i].x,&z[i].y,&z[i].w);
	}
	work();
	for(int i=1;i<=q;i++){
		int a,b;scanf("%d%d",&a,&b);
		printf("%d\n",val[lca(a,b)]);
	}
	return 0;
}

DarkOJ 3551

题意：

给你一张 n n n个点， m m m条边的图，在线询问 q q q组，每次询问从 v v v作为出发点，只能经过边权小于等于 x x x的边，求点权第 k k k大的点。

思路：

首先当然是，克鲁斯卡尔重构一下，这样只要从 v v v开始，找一个最浅的祖先 y y y，满足权值小于等于 x x x；
那么 y y y的子树包含的叶子点，就是满足条件的集合。
那么问题就转变成了，求这个集合第 k k k大；
那么维护子树信息，能用什么数据结构呢：
主席树+dfs序，那么子树就是线性的一段，直接查就行；

（作死想到了线段树合并
可惜无了，线段树合并貌似只能维护离线询问，在所有都合并了之后，权值线段树的结构就变了，如果万能的友友 有能够处理的方法，评论区告诉我~

#include<bits/stdc++.h>
using namespace std;
#define ll long long 

int n,m,q;
struct node{
	int x,y,w;
}z[500040];
int h[100050];
int hh[100050];
int len=0;
int val[200050],ff[200050],fa[200050][20],dep[200050],siz[200050];
int cnt;
vector<int>v[200050];
int tot=0;
int root[200050];
int ls[200050],rs[200050];
struct nod{
	int l,r,num;
}zz[4000050];

bool cmp(node a,node b){
	return a.w<b.w;
}
int clone(int x){
	tot++;
	zz[tot]=zz[x];
	return tot;
} 
void update(int id1,int &id2,int l,int r,int x){
	id2=clone(id1);zz[id2].num++;
	if(l>=r)return ;
	int mid=l+r>>1;
	if(x<=mid)update(zz[id1].l,zz[id2].l,l,mid,x);
	else update(zz[id1].r,zz[id2].r,mid+1,r,x);
}
int query(int id1,int id2,int l,int r,int k){
	if(l>=r)return l;
	int mid=l+r>>1;
	int num=zz[zz[id2].r].num-zz[zz[id1].r].num;
	if(k<=num)return query(zz[id1].r,zz[id2].r,mid+1,r,k);
	else return query(zz[id1].l,zz[id2].l,l,mid,k-num);
}
int num=0;

int find(int x){
	if(x==ff[x])return x;
	return ff[x]=find(ff[x]);
}
void dfs(int x,int pre){
	fa[x][0]=pre;dep[x]=dep[pre]+1;
	siz[x]=1;
	for(int i=1;i<20;i++)fa[x][i]=fa[fa[x][i-1]][i-1];
	int f=0;
	ls[x]=1e9,rs[x]=0;
	for(int i=0;i<v[x].size();i++){
		int to=v[x][i];
		if(to==pre)continue;
		dfs(to,x);
		siz[x]+=siz[to];
		ls[x]=min(ls[x],ls[to]);
		rs[x]=max(rs[x],rs[to]);
		f=1;
	}
	if(!f){
		int pos=lower_bound(hh+1,hh+1+len,h[x])-hh;
		num++;
		update(root[num-1],root[num],1,len,pos);
		ls[x]=rs[x]=num;
	}
}
void work(){
	cnt=n;
	for(int i=1;i<=n;i++)ff[i]=i;
	sort(z+1,z+1+m,cmp);
	for(int i=1;i<=m;i++){
		int a=find(z[i].x);
		int b=find(z[i].y);
		if(a==b)continue;
		val[++cnt]=z[i].w;
		ff[cnt]=ff[a]=ff[b]=cnt;
		v[cnt].push_back(a);
		v[cnt].push_back(b);
		v[a].push_back(cnt);
		v[b].push_back(cnt);
	}
	dfs(cnt,0);
}
int find(int x,int y){
	val[0]=1e9+7;
	for(int i=19;i>=0;i--){
		if(val[fa[x][i]]<=y)x=fa[x][i];
	}
	return x;
}
int main(){
	scanf("%d%d%d",&n,&m,&q);
	for(int i=1;i<=n;i++){
		scanf("%d",&h[i]);
		hh[i]=h[i];
	}
	sort(hh+1,hh+1+n);
	len=unique(hh+1,hh+1+n)-hh-1;
	for(int i=1;i<=m;i++){
		scanf("%d%d%d",&z[i].x,&z[i].y,&z[i].w);
	}
	work();
	int ans=0;
	for(int i=1;i<=q;i++){
		int a,b,c;
		scanf("%d%d%d",&a,&b,&c);
		a=a^ans;b^=ans;c^=ans;
		a=find(a,b);
		if(zz[root[rs[a]]].num-zz[root[ls[a]-1]].num<c)printf("-1\n"),ans=0;
		else {
			ans=hh[query(root[ls[a]-1],root[rs[a]],1,len,c)];
			printf("%d\n",ans);
		}
	}
	return 0;
}

P4768 [NOI2018] 归程
也是一道比较模板的题目吧

平平无奇的AC~

#include<bits/stdc++.h>
using namespace std;
#define ll long long 
typedef pair<int,int> PII;

int n,m,Q,t,K,S;

struct node{
	int x,y,w;
}z[400050];
bool cmp(node a,node b){
	return a.w>b.w;
}
int len=0,head[400050],dis[400050],vis[400050];
priority_queue<PII,vector<PII>,greater<PII>> heap;

int cnt,ff[800050],fa[800050][22];
int len1=0,head1[800050];
int val[800060];
int ans[800060];

int find(int x){
	if(x==ff[x])return x;
	return ff[x]=find(ff[x]);
}

struct edge{
	int e,w,nex;
}ed[800050],ed1[1600050];
void add(int a,int b,int l){
	ed[len].e=b;
	ed[len].w=l;
	ed[len].nex=head[a];
	head[a]=len++;
	
}
void add1(int a,int b){
	ed1[len1].e=b;
	ed1[len1].nex=head1[a];
	head1[a]=len1++;
}
void init(){
	len=0;len1=0;
	for(int i=1;i<=n;i++)head[i]=-1,dis[i]=1e9+7,vis[i]=0;
	for(int i=1;i<=2*n;i++)head1[i]=-1,val[i]=0;
}
void work1(){
	dis[1]=0;
	heap.push({0,1});
	while(heap.size()){
		PII t=heap.top();heap.pop();
		int ver=t.second,dist=t.first;
		if(vis[ver])continue;
		vis[ver]=1;
		for(int i=head[ver];i!=-1;i=ed[i].nex){
			int j=ed[i].e;
			if(dis[j]>dist+ed[i].w){
				dis[j]=dist+ed[i].w;
				heap.push({dis[j],j});
			}
		}
	}
}
void dfs(int x,int pre){
	fa[x][0]=pre;ans[x]=1e9+7;
	for(int i=1;i<=20;i++)fa[x][i]=fa[fa[x][i-1]][i-1];
	int f=0;
	for(int i=head1[x];i!=-1;i=ed1[i].nex){
		int to=ed1[i].e;
		if(to==pre)continue;
		dfs(to,x);
		f=1;
		ans[x]=min(ans[x],ans[to]);
	}
	if(!f)ans[x]=dis[x];
}
void work2(){
	cnt=n;
	for(int i=1;i<=n;i++)ff[i]=i;
	sort(z+1,z+1+m,cmp);
	for(int i=1;i<=m;i++){
		int a=find(z[i].x);
		int b=find(z[i].y);
		if(a==b)continue;
		val[++cnt]=z[i].w;
		ff[cnt]=ff[a]=ff[b]=cnt;
		add1(cnt,a);add1(a,cnt);
		add1(cnt,b);add1(b,cnt);
	}
	dfs(cnt,0);
}
int find(int x,int y){
	for(int i=20;i>=0;i--){
		if(val[fa[x][i]]>y)x=fa[x][i];
	}
	return x;
}
int main(){
	scanf("%d",&t);
	while(t--){
		scanf("%d%d",&n,&m);
		init();
		for(int i=1;i<=m;i++){
			int a,b,c,d;
			scanf("%d%d%d%d",&a,&b,&c,&d);
			add(a,b,c);add(b,a,c);
			z[i].x=a;z[i].y=b;z[i].w=d;
		}
		work1();
		work2();
		scanf("%d%d%d",&Q,&K,&S);
		int res=0;
		for(int i=1;i<=Q;i++){
			int a,b;
			scanf("%d%d",&a,&b);
			a=(a+K*res-1)%n+1;
			b=(b+K*res)%(S+1);
			res=ans[find(a,b)];
			printf("%d\n",res);
		}
	}
	return 0;
}
dplovetree
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
中断动画的演示
05-03
清晰地看到硬件的工作原理过程。
最小生成树 克鲁斯卡尔算法 kruskal
06-30
最小生成树的经典算法。我在代码中加入了详细的文字解释。并以算法导论第二版书中例子为例，得到了相同结果。
克鲁斯卡尔_克鲁斯卡尔_
09-30
利用克鲁斯卡尔算法实现图的最小生成树，是图论中较为基础的算法。
Kruskal重构树详解
m0_61735576的博客
05-16 5153
这棵树有很多独特的性质 就比如我们想知道从节点2到7路径的最大边权是多少，其实就是他们公共祖先这个虚点的点权值 再比如我们想知道从某个点出发，给出一个值，在通过所有边的权值都小于等于这个值时，我们走过多少个点，其实就等于这个点一直往上面找，找到最后一个小于等于这个值的虚点，他的子树的点我们都是可以通过的（因为从上到下点权不上升） 以上这种问题我们都可以通过在重构树上倍增的方式，把时间复杂度压到logn
Kruskal 重构树
nttttt の blog
07-19 177
Kruskal 重构树
kruskal重构树
weixin_55851276的博客
07-12 835
kruskal重构树就是在进行kruskal算法时将边权改成点权，构造出一棵具有2n−1个点的树形结构。
克鲁斯卡尔重构树(Network)
lcl1234567890lcl的博客
09-12 198
Network 要求的是，xxx到yyy路径中边权某一路径的最大边权的最小值 利用克鲁斯卡尔建树，发现某两点未连，就在这两个点之间则插入一个新节点（作为这两个节点的父节点），新节点的边权，在建树完成后会形成一个新的树，其xxx到yyy路径中边权某一路径的最大边权的最小值就是其LCALCALCA的权值。 另外要从新的根节点开始dfsdfsdfs 可以参考这篇博客： 传送门 #pragma GCC optimize(2) #pragma GCC optimize(3,"Ofast","inline") #inc
Kruskal重构树学习笔记（C++）
m0_74036684的博客
01-16 469
Kruskal重构树学习笔记
Kruskal算法、Kruskal重构树、LCA算法
qq_61786525的博客
05-09 963
KruskalKruskalKruskal 算法是一种求解最小生成树的贪心算法。它的基本思想是从图中的边集中依次选取边，使得选出的边不会构成回路，并且满足边权和最小。具体实现过程如下：将原图中的所有边按照边权从小到大排序。依次选取排序后的边，如果这条边的两个端点不在同一个连通块中，则加入该边，将它们之间的连通块合并成一个新的连通块，并把该边加入最小生成树的边集中。重复上述步骤，直至加入 n−1n−1n−1 条边（其中 nnn 表示原图的节点数），此时得到的边集即为原图的最小生成树。KruskalKruska
Java 使用克鲁斯卡尔求最小生成树（源代码）
最新发布
05-17
克鲁斯卡尔（Kruskal）算法是一种用于在无向加权图中找到最小生成树的算法。该算法的基本思想是按照边的权重进行排序，然后从中选择边，但选择的边不能形成一个环。以下是克鲁斯卡尔算法的详细讲解、实现原理及Java...
kr.rar_克鲁斯卡尔_克鲁斯卡尔算法
09-24
克鲁斯卡尔算法 控制台下运行 提供给大家参考
zuixiaoshengchengshu.rar_克鲁斯卡尔_最小 生成树 问题
09-23
最小生成树问题--用克鲁斯卡尔算法的实现
Kruskal重构树学习笔记+BZOJ3732 Network
angzuo8655的博客
07-24 97
今天学了Kruskal重构树，似乎很有意思的样子~ 先看题面： BZOJ 题目大意：$n$ 个点 $m$ 条无向边的图，$k$ 个询问，每次询问从 $u$ 到 $v$ 的所有路径中，最长的边的最小值。 $1\leq n\leq 15000,1\leq m\leq 30000,1\leq k\leq 20000$。 我相信你们看见这题的想法和我一样： 货车运输！最小生成...
Kruskal重构树学习
weixin_45724872的博客
12-02 453
引入 简单来讲，就是在Kruskal算法进行的过程中，我们把最小生成树的边权改为点权; 可以看成是Kruskal算法的扩展使用； 假设原树有nnn个结点，因为最小生成树是n−1n-1n−1条边； 那么重构树有2n−12n-12n−1个结点； 举个例子，比如xxx到yyy连了一条边； 那么重构以后变成这样； 性质 是一个小/大根堆(由建树时边权的排序方式决定) 所有原来的点是叶子节点 LCA(u,v)LCA(u,v)LCA(u,v)的点权是 原图uuu到vvv路径上最大边权的最小值或者最小边权的最大
算法笔记-Kruskal重构树
m0_53899788的博客
10-19 319
Kruskal重构树
克鲁斯卡尔重构树及简单应用
深海鱼！的博客
07-20 285
克鲁斯卡尔重构树，codeforces 809E，2021上海站 Life is a Game，倍增，最近公共祖先。
克鲁斯卡尔最小生成树
09-03
克鲁斯卡尔算法是一种用于求解最小生成树的贪心算法。它的基本思想是，从图中的所有边中选择权重最小的边，然后逐步加入权重次小的边，直到生成树中包含了图中的所有顶点为止。 具体步骤如下： 1. 创建一个空的最小生成树集合，初始时只包含图中的顶点。 2. 将图中所有的边按照权重从小到大排序。 3. 依次遍历排序后的边，如果当前边的两个顶点不在同一个连通分量中，则将该边加入最小生成树集合，并将两个顶点合并到同一个连通分量中。 4. 重复步骤3，直到最小生成树集合中包含了图中的所有顶点。 克鲁斯卡尔算法的时间复杂度为O(ElogE)，其中E为图中的边数。它相比于其他最小生成树算法具有较好的时间复杂度和简单易实现的特点，因此在实际应用中被广泛使用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值