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

最新推荐文章于 2024-04-23 12:00:00 发布
最新推荐文章于 2024-04-23 12:00:00 发布
阅读量717 收藏 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
关注
专栏目录
最小生成树，Prim和Kruskal的原理与实现
小K算法
03-10 322
点击上方蓝字 关注我，涨知识01新农村建设大清都亡了，我们村还没有通网。为了响应国家的新农村建设的号召，村里也开始了网络工程的建设。穷乡僻壤，人烟稀少，如何布局网线，成了当下村委会首个急需...
cpp-图论算法最小生成树Prim算法和Kruskal算法C实现
08-16
本文将详细介绍两种经典算法来解决最小生成树问题：Prim算法和Kruskal算法，并以C语言实现为例进行讲解。 ### Prim算法 Prim算法是一种贪心算法，其基本思想是从一个初始节点开始，逐步添加最短的边，直到连接到...
最小生成树问题：Kruskal算法 AND Prim算法
weixin_33694620的博客
07-31 151
Kruskal算法： void Kruskal ( ) { MST = { } ; //边的集合，最初为空集 while( EdgeAccepted < NumVertex - 1 && E中还有边 ) //MST中边数不到V-1 ...
【C++】两种贪婪算法：Prim 算法和Kruskal算法的实现与有效性证明
最新发布
xixin2233的博客
04-23 1149
1. 本实验使用C++实现了 Kruskal 算法和 Prim 算法两个最小生成树算法,并对不同的图反复进行了测试,验证了算法的正确性。2. Kruskal 算法的实现使用了并查集数据结构判断环的形成,时间复杂度为O(ElogV)。Prim 算法使用了最小堆优先队列实现,时间复杂度为O(V2)。3. 对于稠密图,Kruskal算法由于时间复杂度较低,执行速度较快。对于稀疏图,两种算法时间消耗相近。4. 最小生成树有着广泛的应用,如网络中的最低成本连接,关键路径分析等。
最小生成树（Prim and Kruskal）
weixin_33749131的博客
05-16 156
什么是最小生成树？ 一幅加权图的最小生成树（MST）是它的一颗权值（树中的所有边的权值之和）最小的生成树. 这里介绍最小生成树的两种方法：Prim和Kruskal。 两者区别：Prim在稠密图中比Kruskal优，在稀疏图中比Kruskal劣。Prim是以更新过的节点的连边找最小值，Kruskal是直接将边排序。 两者其实都是运用贪心的思路 Prim： 个人觉得Prim和最短路中的d...
Prim and Kruskal算法使用模板
vocaloid01的博客
06-06 336
Prim 邻接矩阵版： #define INF 0x3f3f3f3f const int MAXN = 105; int N; int map[MAXN][MAXN]; bool book[MAXN];//true为已经加入树的，false则相反 int lenth[MAXN];//注意有的博客这里解释为根到各个点的距离，其实应该是“树”到各个点的距离 int Prime() { ...
python最小生成树kruskal与prim算法详解
09-19
### Python 最小生成树Kruskal与Prim算法详解 #### 一、引言 最小生成树（Minimum Spanning Tree, MST）是图论中的一个重要概念，对于无向图而言，它指的是图的一个子集，该子集中包含了图的所有顶点，并且所有顶点...
最小生成树Kruskal和Prim算法讨论.pdf
11-06
最小生成树是图论中的一个重要概念，用于解决网络优化问题，比如城市间的道路建设或电信网络的布线。它的目标是在保证图连通性的前提下，寻找边权重之和最小的边集合。在这个集合中，任何两条边不会形成环路，因为...
最小生成树Kruskal和Prim算法讨论 (2).pdf
11-06
总的来说，最小生成树的Kruskal和Prim算法是图论中的核心算法，它们在解决网络优化问题中扮演着重要角色。理解并掌握这两种算法有助于解决实际中的各种问题，比如交通网络设计、通信网络规划等。在学习这两种算法时...
最小生成树Prim and Kruskal
hummer123的博客
06-17 277
最近在写一些数据结构的程序，看到图，所以就小结一下. 对于Prim算法，文字方面的叙述就不过多谈了，书上写的很清楚。其实很简单就是：先从一个顶点开始找与其相连的顶点的权值最小的那个，并连接在一起，在以这连个顶点分别找与其他顶点的最短权值边，找到最小的并相连： 具体看程序啦：   #include #include #define MAX 100 #define infinity
Prim与Kruskal算法的最小生成树matlab实现
05-26
Prim与Kruskal算法的最小生成树matlab实现
数学建模 图论 课件 最小生成树 广度和深度搜索
08-19
数学建模 图论 课件 最小生成树 广度和深度搜索 matlab 程序 数学建模 图论 课件 最小生成树 广度和深度搜索 matlab 程序 数学建模 图论 课件 最小生成树 广度和深度搜索 matlab 程序 数学建模 图论 课件 最小生成树 广度和深度搜索 matlab 程序
Prim算法和Kruskal算法的Matlab实现
01-23
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 and kruskal）
weixin_30726161的博客
03-16 137
最小生成树算法 比较经典的是这两种 prim kruskal 思想都是贪心的思想 然而我只会一种...kruskal 这里用到了并查集check关系 先将边权从小到大排序，每次选择没有选择的边中的最小边权，check一下是否会形成环，如果形成环就不选择 否则就选择这条边，就这么做下去... 用邻接表结构来记录边的两个顶点和边权 1 #include<ios...
最小生成树算法（Prim和Kruskal）
Sharing_Li的专栏
05-15 1100
无向连通图的最小生成树         设G=(V,E)是一个无向连通图，生成树上各边的权值之和称为该生成树的代价，在G的所有生成树中，代价最小的生成树即为其最小生成树。 Prim（普里姆）算法的基本思想是：         设 G=(V,E) 是一个无向连通图，令T=(U,TE) 是 G 的最小生成树。T的初始状态为 U＝{v0}(v0∈V),TE={},然后重复执行下述操作：
最小生成树-Prim算法和Kruskal算法
suxue1994的博客
08-10 1048
Prim算法 1.概览 普里姆算法（Prim算法），图论中的一种算法，可在加权连通图里搜索最小生成树。意即由此算法搜索到的边子集所构成的树中，不但包括了连通图里的所有顶点（英语：Vertex (graph theory)），且其所有边的权值之和亦为最小。该算法于1930年由捷克数学家沃伊捷赫·亚尔尼克（英语：Vojtěch Jarník）发现；并在1957年由美国计算机科学家罗伯特·普里姆（英...
MATLAB版本实现的Prim 和Kruskal算法
weixin_34361881的博客
01-04 911
时间久远，文档又找不到了，我已经忘记到底特色点具体在什么地方，归结为一点，就是充分利用了MATLAB语言的批量计算特性。直接贴代码吧，有需要的人自然能看出名堂来。   prim clear all;close all;Graph1;%调用Graph1M文件，产生图1的邻接矩阵%Graph2;%调用Graph2M文件，产生图2的邻接矩阵len=length(graph_adjacent)...
[数学建模]最小生成树
daixd5520的博客
08-22 530
求最小生成树的两种算法:prim算法和kruskal算法 1.prim算法 思想:一个点集合P,一个边集合Q,不断地找以点集合中任意一点为端点的最小边,更新点集合和边集合. Matlab代码:见司书P47 例4.5 2,kruskal算法 思想:先对所有的边按权值排序,每次从没被挑选的边里选权值最小的边（不用管是否与已选边相临），不过要注意：避圈！如果选择边e后形成了圈，则不选边e. Matlab代码：见司书P48 例4.6 3.二者的区别 prim算法是找一个,遍历一遍;而kruskal是一开始排好序,之
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值