最小生成树算法及例题

最新推荐文章于 2022-02-16 10:16:55 发布
最新推荐文章于 2022-02-16 10:16:55 发布
阅读量2k 收藏 2
点赞数
分类专栏： # 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/roadtohacker/article/details/112061019
版权

什么是生成树？对连通图进行遍历，过程中经过的点和边的组合可看成一棵树，也叫生成树

目录

最小生成树引入

世界上有着许许多多的铁路线、公路线，想要从一个城市到另一个城市修一条线路需要许多资金，当然，修路的方式有多种多样，现在我们想知道如何修路能使得这些城市之间形成一个通信网，并且使得总耗费最少呢？

  • 假设有n个城市，那么我们最少需要修n-1条路，这是明显的，把这些路连在一起，加上城市节点，就构成了一棵生成树，在这些生成树中，边权之和最小的就是最小生成树，所以我们可以看出最小生成树不一定是唯一的
  • 最小生成树（Minimum Spanning Tree）简称MST
  • 下面两种算法都是基于贪心的思想

Prim算法

如何构建最小生成树呢？我们需要三个数组：selected，minDist，parent

  • selected数组的作用是判断节点是否已被选
  • minDist数组的作用是记录当前可供选择的边权
  • parent数组的作用是记录这些边的上一个节点
  • 将所有顶点分成两个集合U和V-U，集合U是最小生成树的节点集，最开始为空，集合V-U是尚未被加入到树中的节点，最开始为所有节点
  • 我们从任意一个节点出发，首先把它加入到集合U中，同时用它的所有边去更新minDist数组，使得数组中边总是最小
  • 接着我们搜索一遍minDist中的边，找到最小的那一个，把它所对的节点（不是parent）加入到最小生成树中，同时selected数组记录
    prim算法步骤主要有三步：Update，Scan，Add 也就是更新、搜索、加点，所以prim算法又叫做加点法

习题

洛谷模板题

  • 有两个WA点，第一个点是图是无向图，第二个是可能出现两个点之间有两条边或者更多，这个时候我们要取最短的边，这样需要在输入那里处理一下
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <iomanip>
#include <queue>
#include <stack>
using namespace std;
typedef long long ll;
const int MAXN = 5050;
int edge[MAXN][MAXN];
int selected[MAXN];
int minDist[MAXN];
int parent[MAXN];
int ans = 0;
int tot = 1;
void Prim(int num,int m){
    selected[m] = 1;
    int k,tmp;
    for(int i=1;i<=num;i++){ 
        if(edge[m][i]){
            minDist[i] = edge[m][i];
            parent[i] = m;
        }
    }
    for(int i=1;i<num;i++){
        tmp = 0x3f3f3f3f;
        for(int j=1;j<=num;j++){
            if(!selected[j]&&minDist[j]<tmp){
                k = j;
                tmp = minDist[j];
            } 
        }
        if(selected[k]) continue;
        selected[k] = 1;
        tot++;
        ans += edge[parent[k]][k];
        for(int j=1;j<=num;j++){
            if(!selected[j]&&edge[k][j]<minDist[j]&&edge[k][j]){
                minDist[j] = edge[k][j];
                parent[j] = k;
            }
        }
    }
    if(tot!=num) cout<<"orz"<<endl;
    else cout<<ans<<endl;
}
int main(){
    int n,m;
    cin>>n>>m;
    for(int i=0;i<m;i++){
        int x,y,z;
        cin>>x>>y>>z;
        if(edge[x][y]==0){
            edge[x][y] = z;
            edge[y][x] = z;
        }
        else if(z<edge[x][y]){
            edge[x][y] = z;
            edge[y][x] = z;
        }
    }
    memset(parent,-1,sizeof parent);
    memset(minDist,0x3f,sizeof minDist);
    Prim(n,1);
    return 0;
}

HDU模板题
这道题坑死我了，一直看了两个小时没找到错误，一直提示非法访问内存空间，数组大小也很合适，后来换了C++提交就过了，很奇怪

  • 和上一道题基本一样，唯一需要注意的是使用的变量和数组需要恢复原状
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <iomanip>
#include <queue>
#include <stack>
using namespace std;
typedef long long ll;
const int MAXN = 505;
int edge[MAXN][MAXN];
int selected[MAXN];
int minDist[MAXN];
int parent[MAXN];
int ans = 0;
int tot = 1;
void Prim(int num,int m){
    tot = 1;
    ans = 0;
    selected[m] = 1;
    int k,tmp;
    for(int i=1;i<=num;i++){ 
        if(edge[m][i]){
            minDist[i] = edge[m][i];
            parent[i] = m;
        }
    }
    for(int i=1;i<num;i++){
        tmp = 0x3f3f3f3f;
        for(int j=1;j<=num;j++){
            if(!selected[j]&&minDist[j]<tmp){
                k = j;
                tmp = minDist[j];
            } 
        }
        if(selected[k]) break;
        selected[k] = 1;
        tot++;
        ans += edge[parent[k]][k];
        for(int j=1;j<=num;j++){
            if(!selected[j]&&edge[k][j]<minDist[j]&&edge[k][j]){
                minDist[j] = edge[k][j];
                parent[j] = k;
            }
        }
    }
    if(tot!=num) cout<<"?"<<endl;
    else cout<<ans<<endl;
}
int main(){
    int n,m;
    while(cin>>n>>m){
        if(n==0) break;
        memset(edge,0,sizeof edge);
        for(int i=0;i<n;i++){
            int x,y,z;
            cin>>x>>y>>z;
            if(edge[x][y]==0){
                edge[x][y] = z;
                edge[y][x] = z;
            }
            else if(z<edge[x][y]){
                edge[x][y] = z;
                edge[y][x] = z;
            }
        }
        memset(parent,-1,sizeof parent);
        memset(minDist,0x3f,sizeof minDist);
        memset(selected,0,sizeof selected);
        Prim(m,1);
    }
    return 0;
}

更新一道题

P1265

  • 此题依然是模板，但这个问题是边多，内存又有限制，不适合使用方便的kruskal，需要用prim，可以借助这道题再次熟悉prim
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <iomanip>
#include <queue>
#include <stack>
using namespace std;
typedef long long ll;
const int MAXN = 5050;
int selected[MAXN];
double minDist[MAXN];
int parent[MAXN];
double ans = 0;
int tot = 1;
struct node{
    int x, y;
}st[MAXN];
double DIS(node x, node y){
    double dx = x.x - y.x;
    double dy = x.y - y.y;
    return sqrt(dx * dx + dy * dy);
}
void Prim(int num,int m){
    selected[m] = 1;
    int k;
    double tmp;
    for(int i=1;i<num;i++){ 
        double n = DIS(st[m], st[i]);
        if(n > 0){
            minDist[i] = n;
            parent[i] = m;
        }
    }
    for(int i=1;i<num;i++){
        tmp = 9999999999;
        for(int j=1;j<num;j++){
            if(!selected[j]&&minDist[j]<tmp){
                k = j;
                tmp = minDist[j];
            } 
        }
        if(selected[k]) continue;
        selected[k] = 1;
        tot++;
        ans += DIS(st[parent[k]], st[k]);
        for(int j=1;j<=num;j++){
            double n = DIS(st[k], st[j]);
            if(!selected[j] && n<minDist[j]){
                minDist[j] = n;
                parent[j] = k;
            }
        }
    }
    printf("%.2lf", ans);
}

int main(){
    int n;
    cin>>n;
    for(int i=0;i<n;i++) cin>>st[i].x>>st[i].y;
    memset(parent,-1,sizeof parent);
    memset(minDist,0x3f,sizeof minDist);
    Prim(n,0);
    return 0;
}

Kruskal算法

相对于Prim算法，Kruskal算法的思想是加边，可以称之为加边法，过程如下

  • 把所有边按照权值升序排列，从前往后依次‘回贴’边到图中，每次需要判断图中是否出现环，如果出现就舍弃转向下一条边，这样进行下去，直到所有点都在生成树里，这样就形成了最小生成树
  • 不知道有没有人会有这样的疑问，为什么Kruskal算法能够找到最小生成树，Prim是从顶点出发，向外扩散，肯定能遍历全图，这不难理解；但Kruskal是不停地加边，中间还有舍弃，难道不会漏边吗？
  • 仔细思考可以明白，我们已经将边排好序了，如果后面的边使得前面的边构成的图出现环，可以直接把这条边舍弃掉，因为前面的边已经使现在的顶点连在一片，而这条边只不过是多余的而已
  • 思路已经有了，那么具体如何实现呢？
    这里要用到一点并查集的相关知识，简单来讲，刚开始，不同的顶点属于不同的集合，每次选择一条边加进来都要把这两个点划分到一个集合里面去，这就是典型的并查集，在前面路径压缩优化一下，也就是把所有点直接跟着根节点而不是递归查找
  • 相对于Prim的实现，这一次使用Kruskal显得顺利得多，没有发现什么坑点
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <iomanip>
#include <queue>
#include <stack>
using namespace std;
typedef long long ll;
const int MAXN = 2e5+100;
struct Edge{int x,y,z;}edge[MAXN];
int set[MAXN];
bool cmp(Edge x,Edge y){
    return x.z<y.z;
}
int Findset(int x){
    if(x!=set[x]) set[x] = Findset(set[x]);
    return set[x];
}
void Kruskal(int num,int m){
    int ans = 0;
    int tot = 0;
    for(int i=1;i<=num;i++) set[i] = i;
    for(int i=0;i<m;i++){
        int x = Findset(edge[i].x);
        int y = Findset(edge[i].y);
        if(x == y) continue;
        set[x] = set[y];
        tot++;
        ans += edge[i].z;
        if(tot == num-1) break;
    }
    if(tot == num-1) cout<<ans<<endl;
    else cout<<"orz"<<endl;
}
int main(){
    int n,m;
    cin>>n>>m;
    for(int i=0;i<m;i++) cin>>edge[i].x>>edge[i].y>>edge[i].z;
    sort(edge,edge+m,cmp);
    Kruskal(n,m);
    return 0;
}

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <iomanip>
#include <queue>
#include <stack>
using namespace std;
typedef long long ll;
const int MAXN = 2e5+100;
struct Edge{int x,y,z;}edge[MAXN];
int set[MAXN];
bool cmp(Edge x,Edge y){
    return x.z<y.z;
}
int Findset(int x){
    if(x!=set[x]) set[x] = Findset(set[x]);
    return set[x];
}
void Kruskal(int num,int m){
    int ans = 0;
    int tot = 0;
    for(int i=1;i<=num;i++) set[i] = i;
    for(int i=0;i<m;i++){
        int x = Findset(edge[i].x);
        int y = Findset(edge[i].y);
        if(x == y) continue;
        set[x] = set[y];
        tot++;
        ans += edge[i].z;
        if(tot == num-1) break;
    }
    if(tot == num-1) cout<<ans<<endl;
    else cout<<"?"<<endl;
}
int main(){
    int n,m;
    while(cin>>n>>m){
        if(n==0) break;
        for(int i=0;i<n;i++) cin>>edge[i].x>>edge[i].y>>edge[i].z;
        sort(edge,edge+n,cmp);
        Kruskal(m,n);
    }
    return 0;
}

一个非常好的学习视频

B站链接

Clarence Liu
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
力扣刷题之旅：高阶篇（四）—— 最小生成树算法
欢迎来到“Python算法探索”，我是GT算法工程师，一名热爱计算机算法的博主。在这里，我们将一起深入探索Python世界中的各种算法，从基础到高级，从理论到实践。我参加过很多算法比赛，积累了丰富的经验，希望通过这个播客与你分享。让我们一起用Python探
02-12 530
本文介绍了力扣刷题之旅的高阶篇（）—— 最小生成树算法。通过一道关于最小生成树的题目，我们学习了如何使用Kruskal算法找到加权无向图中的最小生成树，并给出了Python代码示例。最小生成树算法在实际应用中具有广泛的用途，如网络设计、电路设计等。通过不断刷题和学习算法知识，我们可以提高自己的编程能力和解决问题的能力。
图的最小生成树算法（图解+代码）| 学不会来看我系列
流楚丶格念的博客
09-17 6012
普里姆（Prim）算法，也是求加权连通图的最小生成树的算法。基本思想对于图G而言，V是所有顶点的集合；现在，设置两个新的集合U和T，其中U用于存放G的最小生成树中的顶点，T存放G的最小生成树中的边。从所有的 u∈U ，v∈(V-U)（V-U表示除去U的所有顶点）的边中选取权值最小的边（u，v），将顶点v加入U中，将边（u,v）加入集合T中，如此不断重复，直到U=V为止，最小生成树构造完毕，此时集合T中包含了最小生成树中的所有边。克鲁斯卡尔（Kruskal）算法，是用来求加权连通图的最小生成树的算法。
最小生成树例题
juanlansexuehua的博客
03-01 1304
poj 2421 Constructing Roads Time Limit: 2000MS   Memory Limit: 65536K Total Submissions: 23522   Accepted: 10085 Description There are N villages, which are numbered from
C例子：最小生成树（kruskal）
10-02
该程序是我写的博客“一起talk C栗子吧（第五十回：C语言实例--最小生成树二）”的配套程序，共享给大家使用
最小生成树算法例题
weixin_44814196的博客
04-21 1509
目录一、问题描述二、实现思路三、解题代码四、运行结果 一、问题描述   对于下图，试分别采用Prim和Kruskal算法求出其最小生成树。 二、实现思路   最小生成树是由n个顶点，n-1条边，将一个连通图连接起来，且使权值最小的结构。最小生成树可以用Prim算法或Kruskal算法求出。Prim算法又称“加点法”，用于边数较多的带权无向连通图。其方法主要是每次找与之连线权值最小的顶点，将该点加入最小生成树集合中，但是不允许出现闭合回路的情况。Kruskal算法又称“加边法”，用于边数较少的稀疏图，其方
第三部分 图论算法 （第二章 最小生成树）例题
蒟蒻こんにゃく
04-22 408
例题一：繁忙都市 link 思路： Kruskal模板题. #include <bits/stdc++.h> using namespace std; const int N = 1e5 + 10; struct node { int u, v, w; } p[N]; int n, m, tot, k, f[N]; bool cmp(node a, node b) {return a.w < b.w;} int find(int x) {return x == f[x] ?
C例子：最小生成树（prim）
10-02
该程序是我写的博客“一起talk C栗子吧（第五十一回：C语言实例--最小生成树三）”的配套程序，共享给大家使用
最小生成树--普利姆算法（例题）
weixin_54202978的博客
05-31 2499
7-10 公路村村通 (30 分) 现有村落间道路的统计数据表中，列出了有可能建设成标准公路的若干条道路的成本，求使每个村落都有公路连通所需要的最低成本。 输入格式: 输入数据包括城镇数目正整数N（≤1000）和候选道路数目M（≤3N）；随后的M行对应M条道路，每行给出3个正整数，分别是该条道路直接连通的两个城镇的编号以及该道路改建的预算成本。为简单起见，城镇从1到N编号。 输出格式: 输出村村通需要的最低成本。如果输入数据不足以保证畅通，则输出−1，表示需要建设更多公路。 输入样例: 6
c语言贪心算法最小生成树,贪心算法4-最小生成树(Prim算法）
weixin_30767365的博客
05-23 1351
1.问题分析在一个有n个节点的无向连通图G = (V, E)中，V表示顶点集，E表示边集。只需n-1条边就可以使这个图连通，n-1条边要想保证图连通，就必须不含回路，所以我们只需要找出n-1条权值最小且无回路的边即可。需要明确几个概念：生成子图：选中一些边和所有顶点组成的图，称为原图的生成子图。生成树：如果生成子图恰好是一棵树，称为生成树。最小生成树：权值之和最小的生成树，称为最小生成树。2.算法...
最小生成树练习
.
10-04 596
poj 2485   题意：给你一个图的邻接矩阵，求最小生成树，输出的是树中的最大边 poj 1258 题意：和上一题几乎完全相同，求的是最小生成树的总权值 hdu 1879  注意：要用scanf();printf() 输入输出,；另外，用kruskal，不能用以顶点为操作对象的prim. ...
最小生成树例题及其总结
热门推荐
tangzhide123yy的博客
11-02 1万+
目录： 洛谷 P2820 局域网 POJ 2421 Constructing Roads 洛谷 P1111 修复公路 洛谷 P2700 逐个击破 洛谷 P1197 [JSOI2008]星球大战 洛谷 P2502 [HAOI2006]旅行 关于最小生成树的问题差不多有如下几个： 1.模板（加一点修改，比如给的所有边的总边权-最小生成树的总边权或者有些边已经建好，求其他的）如第一
最小生成树的简单例题
Elvirangel的博客
11-04 6718
** 灌溉（最小生成树） ** 到了旱季农业生产的灌溉就成了一个大问题。为了保证灌溉的顺利，某县政府决定投资为各个村之间建立灌溉管道。 输入第1行包括一个整数N，表示某县的村庄的数量。（3≤N≤100），第2行-结尾为一个N×N的矩阵,表示每个村庄之间的距离。虽然在理论上，他们是N行，每行由N个用空格分隔的数组成，实际上，他们限制在80个字符，因此，某些行会紧接着另一些行。当然，对角线
最小生成树例题详解
JKdd123456的博客
03-07 1624
ＯＮＥ： 题目描述 题意： 求ｎ个顶点间的最小生成树，使整个拓扑路径和最小 用 Prim 模板来写 #include &lt;iostream&gt; #include &lt;cstdio&gt; #include &lt;cmath&gt; #include &lt;cstring&gt; #include &lt;algorithm&gt; #include &lt;set&gt...
最小生成树习题集(prime,krushal)
weixin_43736492的博客
08-11 8573
Jungle Roads Time Limit: 1000MS Memory Limit: 10000K Total Submissions: 36699 Accepted: 17228 Description The Head Elder of the tropical island of Lagrishan has a problem. A burst of foreign aid mo...
最小生成树之 prim算法和kruskal算法(以 hdu 1863为例)
happy_lcj
07-19 968
最小生成树的性质 MST性质：设G = (V,E)是连通带权图，U是V的真子集。如果(u,v)∈E,且u∈U,v∈V-U,且在所有这样的边中， (u,v)的权c[u][v]最小，那么一定存在G的一棵最小生成树，(u,v)为其中一条边。 构造最小生成树，要解决以下两个问题： (1).尽可能选取权值小的边，但不能构成回路（也就是环）。 (2).选取n-1条恰当的边以连接网的n个顶点。
最小生成树所有题解
qq_62767608的博客
02-16 1243
1.今天学习了Kruskal算法和Prim算法。 2.完成最小生成树的所有题目。 - [P3366 【模板】最小生成树](https://www.luogu.com.cn/problem/P3366) 题解：该题为模板题，我用的是Kruskal算法。 Kruskal算法核心思想：将所有边根据边权从小到大排序，每次从剩余的边中选择权值较小且边的两个顶点不在同一个集合的边（即不会产生回路的边），加入到生成树中，直到加入了n-1条边为止。 //kruskal #include<bits/st
挑战程序设计竞赛最小生成树习题(4道)及详解：C++实现
qq_45929428的博客
05-17 465
最小生成树POJ 1258:Agri-NetPOJ 2377:Bad CowtractorsPOJ 2395:Out of HayAOJ 2224:Save your cats 这四道题比较基本，没有过多复杂的过程，所以整合在一篇博客，适合学过最小生成树算法后来加深理解 POJ 1258:Agri-Net 点击进入题面 最小生成树模板题，输入为图的邻接矩阵，所以优先考虑prim算 法： #include<iostream> #include<algorithm> using name
prim最小生成树例题图解
最新发布
11-12
prim算法是一种用于解决最小生成树（Minimum Spanning Tree，MST）问题的算法。最小生成树是指在一个连通加权图中找到一棵包含所有顶点并且边权值之和最小的树。 下面以一个例题图来解释prim算法的过程。假设我们有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Clarence Liu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值