最小生成树

Posted lipu123

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了最小生成树相关的知识,希望对你有一定的参考价值。

 

 

给定一个无向图,每条边有一个非负权值。求这个图中最小生成树的所有边的权值之和。生成树是指包含图中所有节点的一棵树,而最小生成树则指一棵所有边的权值之和最小的生成树。

输入

第一行包含两个数,n和m,其中n为节点数,m为边数。下面m行,每行三个非负整数a、b和c,a, b<n,表示a和b之间有一条权值为c的边。

输出

输出一个数,表示一棵最小生成树所有边的权值之和。

样例输入 Copy

5 8
0 1 1
0 2 2
0 3 5
0 4 7
1 2 0
2 3 15
2 4 25
1 4 100

样例输出 Copy

13

提示

技术图片
对于30%的数据,m≤10;
对于50%的数据,m≤1000;
对于100%的数据,m≤100000,c≤2000。
 
算法:

Kruskal(克鲁斯卡尔)算法开始时,认为每一个点都是孤立的,分属于n个独立的集合。

 

 

技术图片

5个集合{ {1},{2},{3},{4},{5} }

 

生成树中没有边

 

 

 

Kruskal每次都选择一条最小的边,而且这条边的两个顶点分属于两个不同的集合。将选取的这条边加入最小生成树,并且合并集合。

 

第一次选择的是<1,2>这条边,将这条边加入到生成树中,并且将它的两个顶点1、2合并成一个集合。

技术图片

4个集合{ {1,2},{3},{4},{5} }

生成树中有一条边{ <1,2> }

第二次选择的是<4,5>这条边,将这条边加入到生成树中,并且将它的两个顶点4、5合并成一个集合。

技术图片

3个集合{ {1,2},{3},{4,5} }

生成树中有2条边{ <1,2> ,<4,5>}

第三次选择的是<3,5>这条边,将这条边加入到生成树中,并且将它的两个顶点3、5所在的两个集合合并成一个集合  

技术图片

2个集合{ {1,2},{3,4,5} }

生成树中有3条边{ <1,2> ,<4,5>,<3,5>}

第四次选择的是<2,5>这条边,将这条边加入到生成树中,并且将它的两个顶点2、5所在的两个集合合并成一个集合。  

 

 

技术图片

1个集合{ {1,2,3,4,5} }

生成树中有4条边{ <1,2> ,<4,5>,<3,5>,<2,5>}

  算法结束,最小生成树权值为19。

  通过上面的模拟能够看到,Kruskal算法每次都选择一条最小的,且能合并两个不同集合的边,一张n个点的图总共选取n-1次边。因为每次我们选的都是最小的边,所以最后的生成树一定是最小生成树。每次我们选的边都能够合并两个集合,最后n个点一定会合并成一个集合。通过这样的贪心策略,Kruskal算法就能得到一棵有n-1条边,连接着n个点的最小生成树。

  Kruskal算法的时间复杂度为O(E*logE),E为边数。

int Find(int x) 并差集 压缩路径

{if(fa[x]==x) return x;fa[x]=Find(fa[x]);}

 

FORa(i,1,n) fa[i]=i; 初始化,将父亲指向自己

sort(edge+1,edge+1+n,cmp);排序

FORa(i,1,m)

{

t1=Find(edge[i].from);t2=Find(edge[i].to);

if(t1!=t2) 并差集合并

cnt++,fa[t1]=t2,ans+=edge[i].dis;

if(cnt==n-1)

cout<<ans;return;

本题代码:

#include<bits/stdc++.h> 
using namespace std;
typedef long long ll;
inline int read()
{
    int x=0;char ch=getchar();
    while(ch<0||ch>9)ch=getchar();
    while(ch>=0&&ch<=9){x=x*10+ch-0;ch=getchar();}
    return x;
}
const int maxn=1e6+100;
int pre[maxn],n,m;
struct node{
    ll u,v,w;
}a[maxn];
bool cmp(node x,node y){
    return x.w<y.w;
} 
void inint(){
    for(int i=0;i<=n;i++){
        pre[i]=i;
    }
}
int find(int h)//找根? 
{    
    return pre[h]==h?h:pre[h]=find(pre[h]); 
}
int merge(node n){
    int x=find(n.u);
    int y=find(n.v);
    if(x!=y){
        pre[x]=y;
        return 1;
    }
    return 0;
} 
int main(){
    cin>>n>>m;
    inint();
    for(int i=1;i<=m;i++){
        a[i].u=read();
        a[i].v=read();
        a[i].w=read();
    }
    sort(a+1,a+m+1,cmp);
    ll num=0,ans=0; 
    for(int i=1;i<=m&&num<=n-1;i++)
    {
        if(merge(a[i])==1)
        {
            num++;
            ans+=a[i].w;
        }
    }
    printf("%lld
",ans);
}

 

克鲁斯卡尔

  1. 并查集加排序
  2. 预处理,现将所有的节点的父亲指向自己
  3. 输入m条边,切记,只需要m条边
  4. 按每一条边的权值排序
  5. 最后并查集来查询,看是否加入到生成树中,注意并查集模板是这样写的

int Find(int x){if(fa[x]==x) return fa[x];  return fa[x]=Find(fa[x]);

  1. 最后查看是否是构造了一颗n个点,n-1条边的最小生成树

普里姆

  1. 对于构造边,就使用链式前向星,但是对于边的话就需要开两倍
  2. 初始化,将dis[](这个点到最小生成树的最近的距离)赋值为一个极大的值,但是不能超过INF的二分之一,即为memset(dis,63,sizeof (dis))为一个较大的值,memset赋值的时候需要赋值为2的x次方-1
  3. 再用一个pair来储存队列节点的信息,宏定义 #define pair<int,int> pp
  4. 放入优先队列priority_queue<pp,vector<pp>,greater<pp> >  q; 小根堆,默认为大根堆
  5. 两个连着的尖括号之间需要打空格
  6. Pair的比较,先比较first,在比较second,所以将dis存入first,u存入second
  7. 最外层循环为队列不为空且最小生成树还没有构建好while(!q.empty()&&cnt<n)
  8. 接着,退出队列中的对头,查看是否出现过,没有出现过就将此点打标记,cnt++,答案加上这条边的权值,扩散连接它的边,放入队列

普里姆的算法就是最短路的贪心思想

#include<cstdio>
#include<queue>
#include<cstring>
#include<utility>
#include<algorithm>
#define FORa(i,s,e) for(i=s;i<=e;i++)
#define R register int
using namespace std;

int n,m,cnt,ans,head[5005],dis[5005],bz[5005];
struct Edge
{
    int next,to,dis;
}edge[400005];
int num_edge;
void Add_edge(int from,int to,int dis)
{
    edge[++num_edge]=(Edge){head[from],to,dis};
    head[from]=num_edge;
}
typedef pair <int,int> pp;
priority_queue <pp,vector<pp>,greater<pp>> q;//first dis     second u
void Prim()
{
    pp ft;
    dis[1]=0;
    q.push(make_pair(0,1));
    while(!q.empty()&&cnt<n)
    {
    ft=q.top(),q.pop();
        if(bz[ft.second]) continue;
        cnt++,ans+=ft.first,bz[ft.second]=1;
        for(R i=head[ft.second];i;i=edge[i].next)
            if(dis[edge[i].to]>edge[i].dis)
                dis[edge[i].to]=edge[i].dis,q.push(make_pair(dis[edge[i].to],edge[i].to));
    }
}
int main()
{
    memset(dis,127,sizeof(dis));
    R from,to,fdis;
    scanf("%d%d",&n,&m);
    for(R i=1;i<=m;i++)
    {
        scanf("%d%d%d",&from,&to,&fdis);
        Add_edge(to,from,fdis),Add_edge(from,to,fdis);
    }
    Prim();
    if (cnt==n)printf("%d",ans);
    else printf("orz");
}

 

以上是关于最小生成树的主要内容,如果未能解决你的问题,请参考以下文章

最小生成树matlab代码Kruskal算法,用于二维网络生成

c语言最小生成树

最小生成树及Prim算法及Kruskal算法的代码实现

数据结构 图连通与最小生成树

次最小生成树 模版

图的最小生成树算法(图解+代码)| 学不会来看我系列