最小生成树的kruskal、prim算法

kruskal算法和prim算法

都说 kruskal是加边法，prim是加点法

这篇解释也不错：这篇

1、kruskal算法

　　因为是加边法，所以这个方法比较合适稀疏图。要码这个需要先懂并查集。因为我不会画好看的图，所以看不懂的话推荐下面博客的说明。这里是下面。

步骤：

1、把每个点都看成一棵树，那么你就会得到一片森林。。。

2、把每棵树之间的距离从小到大排序，即把边排序

3、从小到大取边，把不在同一棵树的点连通到同一棵树上。。。最后你会得到一棵树，就是最小生成树

我去盗图。。。这里的图

给个模板题吧。。HDU1233

#include <iostream>

#include <cstdio>

#include <string>

#include <cstring>

#include <cmath>

#include <sstream>

#include <algorithm>

#include <set>

#include <map>

#include <vector>

#include <queue>

#include <iomanip>

#include <stack>

using namespace std;

typedef long long LL;

const int INF = 0x3f3f3f3f;

const int MAXN = ;

const int MOD = 1e9 + ;

#define MemI(x) memset(x, -1, sizeof(x))

#define Mem0(x) memset(x, 0, sizeof(x))

#define MemM(x) memset(x, 0x3f, sizeof(x))

struct Edge

{

    int u, v, w;

    bool operator < (const Edge &a) const

    {

        return w < a.w;

    }

}edge[MAXN];

int n, ans, fa[];

//找父节点并压缩路径，这是并查集的知识

int Get_f(int x)

{

    if(fa[x] == x)

        return x;

    return fa[x] = Get_f(fa[x]);

}

void Kruskal()

{

    //初始化

    for(int i = ;i <= n;++i)

        fa[i] = i;

    sort(edge, edge + (n - ) * n / );

    ans = ;

    int x, y, cnt = ;

    for(int i = ;i < n * (n - ) / ;++i)

    {

        x = Get_f(edge[i].u), y = Get_f(edge[i].v);

        //加边

        if(x != y)

        {

            ans += edge[i].w;

            fa[x] = y;

            cnt++;

        }

        //加入所有点了

        if(cnt >= n)

            break;

    }

    printf("%d\n", ans);

}

int main()

{

    while(scanf("%d", &n) != EOF && n)

    {

        for(int i = ;i < n * (n - ) / ;++i)

            scanf("%d%d%d", &edge[i].u, &edge[i].v, &edge[i].w);

        Kruskal();

    }

    return ;

}

2、Prim算法

　　这算法写起来跟最短路的 Dijkstra算法很像。来复习一下 Dijkstra算法，先找出距离源点最短的点（这里是找出离一个点最近的路），然后把这个点与。源点连接（这里是连接这两个点），之后再更新最短路（更新到各个点的最短的边，这里代码有点不同）。。。就没有哈哈哈哈。。。直接上上面那道模板题代码吧。。。。。

#include <iostream>

#include <cstdio>

#include <string>

#include <cstring>

#include <cmath>

#include <sstream>

#include <algorithm>

#include <set>

#include <map>

#include <vector>

#include <queue>

#include <iomanip>

#include <stack>

using namespace std;

typedef long long LL;

const int INF = 0x3f3f3f3f;

const int MAXN = ;

const int MOD = 1e9 + ;

#define MemI(x) memset(x, -1, sizeof(x))

#define Mem0(x) memset(x, 0, sizeof(x))

#define MemM(x) memset(x, 0x3f, sizeof(x))

int mp[MAXN][MAXN], dis[MAXN], n, ans;

bool vis[MAXN];

void Prim(int s)

{

    Mem0(vis);

    int i, j;

    for(i = ;i <= n;++i)

        dis[i] = mp[s][i];

    dis[s] = ;

    int v, w;

    vis[s] = true;

    for(i = ;i < n;++i)

    {

        w = INF;

        for(j = ;j <= n;++j)

        {

            if(!vis[j] && dis[j] < w)

            {

                w = dis[j];

                v = j;

            }

        }

        vis[v] = true;

        ans += w;

        for(j = ;j <= n;++j)

            if(!vis[j] && dis[j] > mp[v][j])//这里不同

            dis[j] = mp[v][j];

    }

    printf("%d\n", ans);

}

int main()

{

    int a, b, c;

    while(scanf("%d", &n) != EOF && n)

    {

        MemM(mp);

        ans = ;

        for(int i = ;i < n * (n - ) / ;++i)

        {

            scanf("%d%d%d", &a, &b, &c);

            mp[a][b] = mp[b][a] = c;

        }

        Prim();

    }

    return ;

}

3、 STL与kruskal（理论上 Prim算法应该能用优先队列简化找最短路径的操作，就。。不码这个了）

用map存边，简化排序操作。。。先是模板题练练手，可是跑出来时间慢了十几毫秒

#include <iostream>

#include <cstdio>

#include <string>

#include <cstring>

#include <cmath>

#include <sstream>

#include <algorithm>

#include <set>

#include <map>

#include <vector>

#include <queue>

#include <iomanip>

#include <stack>

using namespace std;

typedef long long LL;

const int INF = 0x3f3f3f3f;

const int MAXN = ;

const int MOD = 1e9 + ;

#define MemI(x) memset(x, -1, sizeof(x))

#define Mem0(x) memset(x, 0, sizeof(x))

#define MemM(x) memset(x, 0x3f, sizeof(x))

int ans, n, fa[MAXN];

int Get_F(int x)

{

    if(fa[x] == x)

        return x;

    return fa[x] = Get_F(fa[x]);

}

int main()

{

    while(scanf("%d", &n) != EOF  && n)

    {

        ans = ;

        multimap<int, pair<int, int> > mp;

        for(int i = ;i <= n;++i)

            fa[i] = i;

        int a, b, c;

        for(int i = ;i < n * (n  - ) / ;++i)

        {

            scanf("%d%d%d", &a, &b, &c);

            mp.insert(make_pair(c, make_pair(a, b)));

        }

        multimap<int, pair<int, int> > :: iterator it;

        int x, y;

        for(it = mp.begin();it != mp.end();++it)

        {

            x = Get_F((*it).second.first), y = Get_F((*it).second.second);

            if(x != y)

            {

                fa[x] = y;

                ans += (*it).first;

            }

        }

        printf("%d\n", ans);

    }

    return ;

}

再给多一道题 UVALive - 6437，先用Prim写一下，感觉Prim比较容易理解，然后再用 kruskal写个简单版的。

Prim思路：。。。。下面注释吧。

#include <iostream>

#include <cstdio>

#include <string>

#include <cstring>

#include <cmath>

#include <sstream>

#include <algorithm>

#include <set>

#include <map>

#include <vector>

#include <queue>

#include <iomanip>

#include <stack>

using namespace std;

typedef long long LL;

const int INF = 0x3f3f3f3f;

const int MAXN = ;

const int MOD = 1e9 + ;

#define MemI(x) memset(x, -1, sizeof(x))

#define Mem0(x) memset(x, 0, sizeof(x))

#define MemM(x) memset(x, 0x3f, sizeof(x))

//点数 n，边数 m ，发电站数量 num， 图 mp， 发电站 power

int ans, n, m, num, vis[MAXN], dis[MAXN], mp[MAXN][MAXN];

int power[MAXN];

int Prim()

{

    int i, j, k;

//    各个城镇到各个发电站的最短距离

    MemM(dis);

    for(i = ;i <= n;++i)

        for(j = ;j < num;++j)

        dis[i] = min(dis[i], mp[i][power[j]]);

    int w, v;

//    还要对 n - num 个点找最短路

    for(i = ;i < n - num;++i)

    {

        w = INF;

        for(j = ;j <= n;++j)

            if(!vis[j] && dis[j] < w)

            {

                w = dis[j];

                v = j;

            }

        vis[v] = true;

        ans += w;

//        这里可以理解为城镇新建了发电站，就看其他城镇到这个新发电站的距离

        for(j = ;j <= n;++j)

            if(!vis[j] && dis[j] > mp[v][j])

            dis[j] = mp[v][j];

    }

    return ans;

}

int main()

{

    int T;

    scanf("%d", &T);

    for(int cas = ;cas <= T;++cas)

    {

        MemM(mp);

        Mem0(vis);

        ans = ;

        scanf("%d%d%d", &n, &m, &num);

        for(int i = ;i <= n;++i)

            mp[i][i] = ;

        int a, b, c;

        for(int i = ;i < num;++i)

        {

            scanf("%d", &power[i]);

            vis[power[i]] = true;//这里先处理发电站比较方便

        }

        for(int i = ;i < m;++i)

        {

            scanf("%d%d%d", &a, &b, &c);

            mp[a][b] = mp[b][a] = c;

        }

        printf("Case #%d: %d\n", cas, Prim());

    }

    return ;

}

Kruskal。。。这道题把所有发电站都先放到一个集合里，那么最后出来的最小生成树就是答案了。。。。具体点就是把所有发电站的祖先都设为同一个，这样不管连接哪一个发电站都有共同祖先。

慢了30ms左右

#include <iostream>

#include <cstdio>

#include <string>

#include <cstring>

#include <cmath>

#include <sstream>

#include <algorithm>

#include <set>

#include <map>

#include <vector>

#include <queue>

#include <iomanip>

#include <stack>

using namespace std;

typedef long long LL;

const int INF = 0x3f3f3f3f;

const int MAXN = ;

const int MOD = 1e9 + ;

#define MemI(x) memset(x, -1, sizeof(x))

#define Mem0(x) memset(x, 0, sizeof(x))

#define MemM(x) memset(x, 0x3f, sizeof(x))

int ans, n, m, k, fa[MAXN];

int Get_F(int x)

{

    if(fa[x] == x)

        return x;

    return fa[x] = Get_F(fa[x]);

}

int main()

{

    int T;

    scanf("%d", &T);

    for(int cas = ;cas <= T;++cas)

    {

        multimap<int, pair<int, int> > mp;

        multimap<int, pair<int, int> > :: iterator it;

        ans = ;

        scanf("%d%d%d", &n, &m, &k);

        for(int i = ;i <= n;++i)

            fa[i] = i;

        int a, b, c;

        //处理发电站

        scanf("%d", &a);

        for(int i = ;i < k;++i)

        {

            scanf("%d", &b);

            fa[b] = a;

        }

        for(int i = ;i < m;++i)

        {

            scanf("%d%d%d", &a, &b, &c);

            mp.insert(make_pair(c, make_pair(a, b)));

        }

        ans = ;

        int x, y;

        for(it = mp.begin();it != mp.end();++it)

        {

            x = Get_F((*it).second.first), y = Get_F((*it).second.second);

            if(x != y)

            {

                ans += (*it).first;

                fa[x] = y;

            }

        }

        printf("Case #%d: %d\n", cas, ans);

    }

    return ;

}

最小生成树的kruskal、prim算法的更多相关文章

最小生成树（Kruskal+Prim）--模板
最小生成树-----在连通网的所有生成树中,所有边的代价和最小的生成树,称为最小生成树. 应用场景 1.假设以下情景,有一块木板,板上钉上了一些钉子,这些钉子可以由一些细绳连接起来.假设每个钉子可以通 ...
数据结构与算法--最小生成树之Prim算法
数据结构与算法--最小生成树之Prim算法加权图是一种为每条边关联一个权值或称为成本的图模型.所谓生成树,是某图的一棵含有全部n个顶点的无环连通子图,它有n - 1条边.最小生成树(MST)是加权图 ...
hiho 1097 最小生成树一·Prim算法（最小生成树）
题目: 时间限制:10000ms 单点时限:1000ms 内存限制:256MB 描述最近,小Hi很喜欢玩的一款游戏模拟城市开放出了新Mod,在这个Mod中,玩家可以拥有不止一个城市了! 但是,问 ...
数据结构之最小生成树Prim算法
普里姆算法介绍普里姆(Prim)算法,是用来求加权连通图的最小生成树算法基本思想:对于图G而言,V是所有顶点的集合:现在,设置两个新的集合U和T,其中U用于存放G的最小生成树中的顶点,T存放G的最 ...
POJ-3026(图上的最小生成树+prim算法+gets函数使用)
Borg Maze POJ-3026 一开始看到这题是没有思路的,看了题解才知道和最小生成树有关系. 题目的意思是每次走到一个A或者S就可以分为多个部分继续进行搜索.这里就可以看出是从该点分出去的不同 ...
MAT之prim算法
prim算法边赋以权值的图称为网或带权图,带权图的生成树也是带权的,生成树T各边的权值总和称为该树的权. 最小生成树(MST):权值最小的生成树. 生成树和最小生成树的应用:要连通n个城市需要n-1 ...
Prim算法（普里姆算法）
描述: 一个连通图的生成树是指一个极小连通子图,它含有图中的全部顶点,但只有足以构成一棵树的 n-1 条边.我们把构造连通网的最小代价生成树成为最小生成树.而Prim算法就是构造最小生成树的一种算法. ...
数据结构与算法系列研究七——图、prim算法、dijkstra算法
图.prim算法.dijkstra算法 1. 图的定义图(Graph)可以简单表示为G=<V, E>,其中V称为顶点(vertex)集合,E称为边(edge)集合.图论中的图(graph ...
贪心算法-最小生成树Kruskal算法和Prim算法
Kruskal算法: 不断地选择未被选中的边中权重最轻且不会形成环的一条. 简单的理解: 不停地循环,每一次都寻找两个顶点,这两个顶点不在同一个真子集里,且边上的权值最小. 把找到的这两个顶点联合起来 ...
最小生成树--Prim算法，基于优先队列的Prim算法，Kruskal算法，Boruvka算法，“等价类”UnionFind
最小支撑树树--Prim算法,基于优先队列的Prim算法,Kruskal算法,Boruvka算法,“等价类”UnionFind 最小支撑树树前几节中介绍的算法都是针对无权图的,本节将介绍带权图的最小 ...

随机推荐

C#中ref和out的作用和区别
相同点:方法的定义和调用都必须显示使用ref.out关键字.都会导致参数按引用传递. 不同点:传递给ref关键字的参数必须赋初始值,而out不用.out关键字会清空变量,即使变量已经赋值也不行,退出函 ...
POJ-3481 Double Queue (splay)
The new founded Balkan Investment Group Bank (BIG-Bank) opened a new office in Bucharest, equipped w ...
SOA-WebService
一.创建Web服务方法在项目上右击选择新建项>>Web服务(ASMX),并命名,如MyWebService.asmx 二.注意事项所有需要外界调用的方法上端均需增加特性[WebMeth ...
21天学通C++学习笔记（四）：数组和字符串
1. 数组概念是一组元素这些元素是相同的数据类型按顺序存储到内存中目的是避免在业务需要时去重复声明很多同类型的变量初始化分别初始化:int i [5] = {1,2,3,4,5}; 全部 ...
封闭类------新标准c++程序设计
封闭类: 一个类的成员变量如果是另一个类的对象,就称之为“成员对象”.包含成员对象的类叫封闭类. #include<iostream> using namespace std; cl ...
PHP7 - MongoDB Driver 使用心得
php7 只能使用Mongodb driver来驱动mongodb. 使用Mongodb Driver连接数据库刚开始使用Mongodb Driver的时候我是拒绝的.查看官方文档只看到一排的类和不 ...
loj #6201. 「YNOI2016」掉进兔子洞
#6201. 「YNOI2016」掉进兔子洞您正在打galgame,然后突然发现您今天太颓了,于是想写个数据结构题练练手: 给出一个长为 nnn 的序列 aaa. 有 mmm 个询问,每次询问三个区 ...
HDU6308-2018ACM暑假多校联合训练1011-Time Zone
题目大意就是给你UTC-8时区的时间让你求对应时区的时间哇这个题看似简单,但是一开始怎么都过不了啊同学用自己写的read过了,后来看了一下各位大佬说改成分钟随便过,就随便过了 Problem ...
Java FileInputStream与FileReader的区别
在解释Java中FileInputStream和FileReader的具体区别之前,我想讲述一下Java中InputStream和Reader的根本差异,以及分别什么时候使用InputStream和R ...
JSP标签的用法
JSP动作标签: 通过动作标签,程序员可以在JSP页面中把页面的显示功能部分封装起来,是整个页面更简洁和易于维护 <jsp:useBean> 装载一个将在JSP页面中使用的JavaBea ...

最小生成树的kruskal、prim算法

最小生成树的kruskal、prim算法的更多相关文章

随机推荐

热门专题