图论 之 最小生成树 (Kruskal and Prim)

最新推荐文章于 2022-12-14 20:34:50 发布
最新推荐文章于 2022-12-14 20:34:50 发布
阅读量674 收藏 1
点赞数
分类专栏： C++ OJ 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bolininahuaalex/article/details/38794603
版权
OJ 同时被 3 个专栏收录
158 篇文章 0 订阅
订阅专栏
C++
12 篇文章 0 订阅
订阅专栏
图论
2 篇文章 0 订阅
订阅专栏

一个有 n 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有 n 个结点，并且有保持图连通的最少的边。最小生成树可以用kruskal（克鲁斯卡尔）算法或Prim（普里姆）算法求出。

生成树是否存在 等价于  图是否连通

JD 1024：畅通工程

题目分析：给图，求最小生成树，Kruskal  和  Prim都试试

Kruskal AC_CODE

const int maxn = 108 ;
const int inf = 1<<30 ;
int n , m ;
struct edge{
    int a , b , cost ;
    bool friend operator<(const edge &A , const edge &B){
        return A.cost < B.cost ;
    }
}e[maxn];
 
int fat[maxn] ;
void init(){
    for(int i = 0;i < maxn;i++){
        fat[i] = i ;
    }
}
int get_Fat(int x){
    if(x == fat[x]) return x ;
    else return fat[x] = get_Fat(fat[x]) ;
}
 
void Merg(int u , int v){
    int fu = get_Fat(u) ;
    int fv = get_Fat(v) ;
    if(fu != fv){
        fat[fu] = fv ;
    }
}
bool same(int u , int v){
    int fu = get_Fat(u) ;
    int fv = get_Fat(v) ;
    if(fu == fv) return true ;
    else return false ;
}
 
int main(){
    int i , j , k ;
    //freopen("in.txt" , "r" , stdin) ;
    while(scanf("%d%d",&n, &m) != EOF){
        if(n == 0) break ;
        for(i = 0;i < n;i++){
            scanf("%d%d%d",&e[i].a,&e[i].b,&e[i].cost) ;
        }
        sort(e , e + n) ;
        int ans = 0 ;
        init() ;
        set<int> node ;
        for(i = 0;i < n;i++){
            int a = e[i].a ;
            int b = e[i].b ;
            if(!same(a , b)){
                Merg(a , b) ;
                ans += e[i].cost ;
                node.insert(a) ;
                node.insert(b) ;
            }
        }
        if(node.size() == m) printf("%d\n",ans) ;
        else puts("?") ;
    }
    return 0 ;
}

JD 1017:还是畅通工程

题目分析：与1024一样啦，没什么区别，求最小生成树

Kruskal AC_CODE

const int maxn = 108 ;
const int inf = 1<<30 ;
int n , m ;
struct edge{
    int a , b , cost ;
    bool friend operator<(const edge &A , const edge &B){
        return A.cost < B.cost ;
    }
}e[maxn*maxn/2];
 
int fat[maxn] ;
void init(){
    for(int i = 0;i < maxn;i++){
        fat[i] = i ;
    }
}
int get_Fat(int x){
    if(x == fat[x]) return x ;
    else return fat[x] = get_Fat(fat[x]) ;
}
 
void Merg(int u , int v){
    int fu = get_Fat(u) ;
    int fv = get_Fat(v) ;
    if(fu != fv){
        fat[fu] = fv ;
    }
}
bool same(int u , int v){
    int fu = get_Fat(u) ;
    int fv = get_Fat(v) ;
    if(fu == fv) return true ;
    else return false ;
}
 
int main(){
    int i , j , k ;
    //freopen("in.txt" , "r" , stdin) ;
    while(scanf("%d",&n) != EOF){
        if(n == 0) break ;
        int m = n*(n-1)/2 ;
        for(i = 0;i < m;i++){
            scanf("%d%d%d",&e[i].a,&e[i].b,&e[i].cost) ;
        }
        sort(e , e + m) ;
        int ans = 0 ;
        init() ;
        for(i = 0;i < m;i++){
            int a = e[i].a ;
            int b = e[i].b ;
            if(!same(a , b)){
                Merg(a , b) ;
                ans += e[i].cost ;
            }
        }
        printf("%d\n",ans) ;
    }
    return 0 ;
}

JD 1012:畅通工程

题目分析：就是并查集的应用啦，判断有几个等价类

AC_CODE

const int maxn = 1008 ;
int fat[maxn] ;
int n , m ;
void init(){
    for(int i = 0;i < maxn;i++)
        fat[i] = i ;
}
int GetFat(int x){
    if(x == fat[x]) return x ;
    else fat[x] = GetFat(fat[x]) ;
}
 
void Merg(int u , int v){
    int fu = GetFat(u) ;
    int fv = GetFat(v) ;
    if(fu != fv){
        fat[fu] = fv ;
    }
}
int main(){
    //freopen("in.txt","r",stdin) ;
    int i , j , k , u , v ;
    while(cin >> n){
        if(n == 0) break ;
        cin >> m ;
        init() ;
        for(i = 0;i < m;i++){
            scanf("%d%d",&u,&v) ;
            Merg(u , v) ;
        }
        set<int> s ;
        for(i = 1;i <= n;i++){
            s.insert(GetFat(i)) ;
        }
        printf("%d\n",s.size() - 1) ;
    }
}

JD 1028：继续畅通工程

题目分析：最小生成树，用Kruskal

Kruskal AC_CODE

const int maxn = 108 ;
const int inf = 1<<30 ;
int n , m ;
struct edge{
    int a , b , cost , flag;
    bool friend operator<(const edge &A , const edge &B){
        if(A.flag == B.flag) return A.cost < B.cost ;
        return A.flag > B.flag ;
    }
}e[maxn*maxn/2];
 
int fat[maxn] ;
void init(){
    for(int i = 0;i < maxn;i++){
        fat[i] = i ;
    }
}
int get_Fat(int x){
    if(x == fat[x]) return x ;
    else return fat[x] = get_Fat(fat[x]) ;
}
 
void Merg(int u , int v){
    int fu = get_Fat(u) ;
    int fv = get_Fat(v) ;
    if(fu != fv){
        fat[fu] = fv ;
    }
}
bool same(int u , int v){
    int fu = get_Fat(u) ;
    int fv = get_Fat(v) ;
    if(fu == fv) return true ;
    else return false ;
}
 
int main(){
    int i , j , k ;
    //freopen("in.txt" , "r" , stdin) ;
    while(scanf("%d",&n) != EOF){
        if(n == 0) break ;
        int m = n*(n-1)/2 ;
        for(i = 0;i < m;i++){
            scanf("%d%d%d%d",&e[i].a,&e[i].b,&e[i].cost,&e[i].flag) ;
        }
        sort(e , e + m) ;
        int ans = 0 ;
        init() ;
        for(i = 0;i < m;i++){
            int a = e[i].a ;
            int b = e[i].b ;
            if(!same(a , b)){
                Merg(a , b) ;
                ans += e[i].flag ? 0 : e[i].cost ;
            }
        }
        printf("%d\n",ans) ;
    }
    return 0 ;
}

JD 1347：孤岛连通工程

题目分析：就是求最小生成树

KruskalAC_CODE

typedef long long LL ;
const int inf = 1<<30 ;
const int maxn = 1008 ;
int n , m ;
int fat[maxn] ;
struct Node{
    int u , v , d ;
    Node(){}
    Node(int a , int b , int c):u(a),v(b),d(c){}
    bool friend operator<(const Node &A , const Node &B){
        return A.d < B.d ;
    }
}edge[maxn*10];
void init(){
    for(int i = 1;i <= n;i++)
        fat[i] = i ;
}
int GetFat(int x){
    if(x == fat[x]) return x ;
    else return fat[x] = GetFat(fat[x]) ;
}
bool Same(int u ,int v){
    int fu = GetFat(u) ;
    int fv = GetFat(v) ;
    if(fu == fv) return true ;
    else return false ;
}
 
void Merge(int u ,int v){
    int fu = GetFat(u) ;
    int fv = GetFat(v) ;
    if(fu != fv){
        fat[fu] = fv ;
    }
}
 
int main(){
    int i , j , k , u , v , d;
    //freopen("in.txt","r",stdin) ;
    while(scanf("%d%d",&n,&m) != EOF){
        for(i = 0;i < m;i++){
            scanf("%d%d%d",&edge[i].u,&edge[i].v,&edge[i].d) ;
        }
        sort(edge , edge + m) ;
        int ans = 0 ;
        Node e ;
        init() ;
        int cnt = 0 ;
        for(i = 0;i < m;i++){
            e = edge[i] ;
            if(!Same(e.u , e.v)){
                ans += e.d ;
                Merge(e.u , e.v) ;
                cnt++ ;
            }
        }
        if(cnt < n - 1) puts("no") ;
        else printf("%d\n",ans) ;
    }
}

JD 1545：奇怪的连通图

题目分析：这里不是求最小生成树，只要求1与n连通，且使得边长的最大值最小。可利用Kruskal算法思想，1到n连通即可，无须构成最小生成树。

AC_CODE

const int maxn = 10008 ;
const int maxm = 100008 ;
int fat[maxn] ;
int n , m ;
struct edge{
    int u , v , d ;
    friend bool operator<(const edge &A , const edge &B){
        return A.d < B.d ;
    }
}e[maxm];

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

int getFat(int x){
    if(x == fat[x]) return x ;
    else return fat[x] = getFat(fat[x]) ;
}

bool same(int u , int v){
    int fu = getFat(u) ;
    int fv = getFat(v) ;
    return fu == fv ;
}

void Merg(int u , int v){
    int fu = getFat(u) ;
    int fv = getFat(v) ;
    if(fu != fv){
        fat[fu] = fv ;
    }
}

int main(){
    int i  , j , k ;
    //freopen("in.txt","r",stdin) ;
    while(scanf("%d%d",&n,&m) != EOF){
        for(i = 0;i < m;i++)
            scanf("%d%d%d",&e[i].u,&e[i].v,&e[i].d) ;
        sort(e , e + m) ;
        init() ;
        for(i = 0;i < m;i++){
            if(!same(1 , n)){
                Merg(e[i].u , e[i].v) ;
                k = e[i].d ;
            }
            else break ;
        }
        if(same(1 , n)) printf("%d\n",k) ;
        else puts("-1") ;
    }
    return 0 ;
}

JD 1417：变型金刚

题目分析：与1545类似，只不过这里要构成最小生成树。还有，输入时结点的编号用字符串表示的，要hash成整数。其他都一样了。。。

Kruskal AC_CODE

const int maxn = 108 ;
const int maxm = 10008 ;
int fat[maxn] ;
int n , m ;
map< string , int > mp ;
struct edge{
    int u , v , d ;
    edge(){}
    edge(int a , int b , int c):u(a),v(b),d(c){}
    friend bool operator<(const edge &A , const edge &B){
        return A.d < B.d ;
    }
}e[maxm];

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

int getFat(int x){
    if(x == fat[x]) return x ;
    else return fat[x] = getFat(fat[x]) ;
}

bool same(int u , int v){
    int fu = getFat(u) ;
    int fv = getFat(v) ;
    return fu == fv ;
}

void Merg(int u , int v){
    int fu = getFat(u) ;
    int fv = getFat(v) ;
    if(fu != fv){
        fat[fu] = fv ;
    }
}

int main(){
    int i  , j , k , a , b , c ;
    //freopen("in.txt","r",stdin) ;
    string s ;
    while(scanf("%d%d",&n,&m) != EOF){
        mp.clear() ;
        k = 1 ;
        for(i = 0;i < m;i++){
            cin >> s ;
            if(mp.find(s) == mp.end())
                mp[s] = k++ ;
            a = mp[s] ;
            cin >> s ;
            if(mp.find(s) == mp.end())
                mp[s] = k++ ;
            b = mp[s] ;
            scanf("%d",&c) ;
            e[i] = edge(a , b , c) ;
        }
        sort(e , e + m) ;
        init() ;
        int t = 0 ;
        for(i = 0;i < m;i++){
            if(!same(e[i].u , e[i].v)){
                Merg(e[i].u , e[i].v) ;
                k = e[i].d ;
                t++ ;
            }
        }
        if(t == n - 1) printf("%d\n",k) ;
        else puts("My God") ;
    }
    return 0 ;
}


玻璃年华Alex
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Matlab 最小生成树算法（MST，Kruskal算法）
dayuhaitang1的博客
01-01 1206
Matlab 最小生成树算法（MST，Kruskal算法）
Kruskal算法 matlab实现
10-23
无约束条件下克鲁斯卡尔(Kruskal)算法—Matlab实现
Python小白的数学建模课-18.最小生成树问题
youcans的博客
07-13 6476
最小生成树（MST）是图论中的基本问题，具有广泛的实际应用，在数学建模中也经常出现。路线设计、道路规划、官网布局、公交路线、网络设计，都可以转化为最小生成树问题，如要求总线路长度最短、材料最少、成本最低、耗时最小。 最小生成树的典型算法有普里姆算法（Prim算法）和克鲁斯卡算法（Kruskal算法）。 本文基于 NetworkX 工具包，通过例程详细介绍最小生成树问题的求解。
个人数学建模算法库之图的最小生成树模型
ncu5509121083的博客
11-06 1169
图的最小生成树模型。Kruskal算法和Prim算法
【数学建模笔记】4.多目标规划+最短路径+最小生成树的简单理解
Imagine_cc的博客
07-07 1537
对多目标规划+最短路径+最小生成树思想的简单理解
cpp-图论算法最小生成树Prim算法和Kruskal算法C实现
08-16
图论算法：最小生成树——Prim算法和Kruskal算法C 实现
最小生成树算法之Prim算法
01-01
这就叫最小生成树算法，最典型的两种算法就是Kruskal算法和本文要讲的Prim算法。 2.Prim算法的步骤是什么？ 这就要涉及一些图论的知识了。 a.假定图的顶点集合为V，边集合为E. b.初始化点集合U={u}.//u为V中的任意...
matlab最小生成树算法
06-20
matlab算法，可以解决最小生成树算法以及类似问题关于最小生成树，学过图论的都懂，这里就不做介绍。 下面是一个例题，附有Kruskal算法和Prim算法。
leetcode耗时-MazeAlgorithms:使用最小生成树和一些递归算法实现的随机迷宫生成器
07-01
关键词程序内容生成，无向图，最小生成树，递归除法，A星搜索 - 准备 - 我们的旧规则说，在实现任何图算法之前，让我们定义一些抽象数据类型(ADT) 来表示图及其类方法。 ADT 是组织我们代码逻辑的基础。 此处提供了...
C++图论专题(form Alex_Wei
08-07
最短路（Bellman-Ford，Dijsktra，SPFA，Johnson，Floyd），差分约束，最小生成树（Kruskal，Prim，Boruvka），有向图与无向图连通性（割点，割边，E-BCC 和 SCC 的缩点），欧拉回路。 适合刚接触C++，并对基础数据...
Prim与Kruskal算法的最小生成树matlab实现
05-26
Prim与Kruskal算法的最小生成树matlab实现
数学建模常用经典算法集合均已成功编译-最小生成树算法MSTA.rar
08-13
数学建模常用经典算法集合均已成功编译-最小生成树算法MSTA.rar 数学建模常用经典算法集合（均已成功编译） 有偿代做，如有需要请联系QQ 1170906655，中介勿扰！ 层次分析算法AHP.rar 单源最短路径算法SPA.rar 动态规划算法DPA.rar 二分图最大匹配算法BGMMA.rar 分支定界法CBA.rar 粒子群算法PSA.rar 蒙特卡洛算法MCA.rar 模拟退火算法SAA.rar 排队论算法QTA.rar 遗传算法GA.rar 蚁群算法ACA.rar 元胞自动机CA.rar 最大流量算法MFA.rar 最小生成树算法MSTA.rar 有偿代做，如有需要请联系QQ 1170906655，中介勿扰！
Prim算法和Kruskal算法的Matlab实现
01-23
Prim算法和Kruskal算法的Matlab实现
数学建模 图论 课件 最小生成树 广度和深度搜索
08-19
数学建模 图论 课件 最小生成树 广度和深度搜索 matlab 程序 数学建模 图论 课件 最小生成树 广度和深度搜索 matlab 程序 数学建模 图论 课件 最小生成树 广度和深度搜索 matlab 程序 数学建模 图论 课件 最小生成树 广度和深度搜索 matlab 程序
管道铺设算法三级项目（最小生成树）
10-24
通过prim计算最小生成树。读取文本数据（矩阵），保存为二维数组格式，通过prim算法得到最小生成树的数组格式，并将其保存为文本。最后画出简易图。
Kruskal 算法与 Prim 算法
qq_39749300的博客
09-02 2266
一：无向带权图的最小生成树 无向带权图是图论算法领域中的一种基础模型。它的代码实现我们就不在这篇文章中介绍了，大家可以参考文章后面给出的代码链接。下图为一个无向带权图的示例： 接下来我们着重介绍一下图的生成树与最小生成树的概念。 什么是图的生成树呢？ 首先，只有一个联通图才有会有图的生成树，也就是说，给定的图的联通分量的个数必须是 1 。 然后，在一个联通图 GGG 中，如果取它全部顶点和一部分边构成一个子图 G′G'G′，若子图 G′G'G′ 的所有边能够使得全部的顶点联通且不形成任何的回路，则称子图
第二十一章 Prim算法与Kruskal算法（通俗证明与详细讲解）
Turing_Sheep的博客
12-14 2972
用通俗的证明和详细的代码解析帮助你理解并掌握最小生成树问题中的两个算法：prim算法和kruskal算法。
[数学建模]最小生成树
daixd5520的博客
08-22 486
求最小生成树的两种算法:prim算法和kruskal算法 1.prim算法 思想:一个点集合P,一个边集合Q,不断地找以点集合中任意一点为端点的最小边,更新点集合和边集合. Matlab代码:见司书P47 例4.5 2,kruskal算法 思想:先对所有的边按权值排序,每次从没被挑选的边里选权值最小的边（不用管是否与已选边相临），不过要注意：避圈！如果选择边e后形成了圈，则不选边e. Matlab代码：见司书P48 例4.6 3.二者的区别 prim算法是找一个,遍历一遍;而kruskal是一开始排好序,之
数学建模学习（18）：图与网络模型之图的最小生成树问题详细讲解，超详细！
全栈川川
08-17 1263
文章目录介绍懒人法立方体图的最小生成树始于指定根节点的最小生成森林总结 介绍 你是否在担心不会写算法？没问题，我在这里直接调用函数来做最小生成树。当然呢？如果你会写算法那是再好不过。在本文章，我讲一个懒人函数调用方法。 懒人法 为什么叫懒人？直接调用函数就ok。隆重介绍下minspantree函数，专门用于求图的最小生成树。 语法如下： T = minspantree(G) 返回图 G 的最小生成树 T。 T = minspantree(G,Name,Value) 使用一个或多个名称-值对组参数指定的其
最小生成树kruskal算法
最新发布
06-09
最小生成树 Kruskal 算法是一种基于贪心算法的图论算法，用于求带权无向图的最小生成树。其核心思想是将边按照权值从小到大排序，然后依次加入图中，如果加入一条边后形成了环，则不加入该边，直到加入 n-1 条边为止。这里的 n 是图中节点的个数。 具体步骤如下： 1. 将图中边按照权值从小到大排序。 2. 初始化一个空的集合 S，表示当前生成树中的边集。 3. 依次取出排序后的每一条边，如果这条边的两个端点不在同一个连通分量中，则将这条边加入集合 S 中，否则跳过该边。 4. 重复步骤 3 直到集合 S 中包含了 n-1 条边，其中 n 是图中节点的个数。 Kruskal 算法的时间复杂度为 O(mlogm)，其中 m 是边数。它比另一种常用的最小生成树算法 Prim 算法更加适用于稀疏图。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值