Prim算法求最小生成树
给定一个 n 个点 m 条边的无向图,图中可能存在重边和自环,边权可能为负数。
求最小生成树的树边权重之和,如果最小生成树不存在则输出 impossible
。
给定一张边带权的无向图 G=(V,E),其中 V 表示图中点的集合,E 表示图中边的集合,n=|V|,m=|E|。
由 V 中的全部 n 个顶点和 E 中 n−1 条边构成的无向连通子图被称为 G 的一棵生成树,其中边的权值之和最小的生成树被称为无向图 G 的最小生成树。
输入格式
第一行包含两个整数 n 和 m。
接下来 m 行,每行包含三个整数 u,v,w,表示点 u 和点 v 之间存在一条权值为 w 的边。
输出格式
共一行,若存在最小生成树,则输出一个整数,表示最小生成树的树边权重之和,如果最小生成树不存在则输出 impossible
。
数据范围
1≤n≤500,
1≤m≤105,
图中涉及边的边权的绝对值均不超过 10000。
输入样例:
4 5
1 2 1
1 3 2
1 4 3
2 3 2
3 4 4
输出样例:
6
最小生成树:
在给定的无向图中,用最少的边将所有的点连接起来且边长的和最小,。
prim算法构造最小生成树:
维护了一个<v,u>
的点集和边集,代表着最小生成树。
- 任选一个点加入
v
中,作为最小生成树的起点。 - 选择与该点相连的距离最小的点加入
v
边加入u
- 选择与现有
v
中的点距离最近的点加入v
,边加入u
- 重复上述过程,直到所有点都加入
v
,则<v,u>
就代表着最小生成树。如果存在点不能加入v
就证明该图不是连通图,不存在最小生成树 (存在点不能相通)。
简言之:最小生成树就是采用贪心策略,每次都将距离已经联通部分最近的点和边加入联通部分,不断地扩大联通块儿最后直到将所有点联通起来,此时的边长和最小。
代码:C++
朴素Prim算法
写法类似于 朴素Dijkstra求最短路**
#include<bits/stdc++.h>
using namespace std;
const int N = 510,INF=0x3f3f3f3f;
int n,m,a[N][N];
int st[N],d[N];
//st[]记录某个点已经存在在联通块中
//d[]记录着点到联通快的最小距离。
int res; //记录最终最小生成树的边长和
int prim()
{
memset(d,0x3f,sizeof d);
for(int i=0;i<n;i++)
{
int t=-1;
for(int j=1;j<=n;j++) //如果联通块儿中还没有点就以1为起点,如果联通块儿中已经有点了就选择距离联通块儿最近的点,用t记录。
if(!st[j] && (t==-1 || d[j]<d[t])) t=j;
if(i && d[t]==INF) return INF; //如果某个点与联通块儿不连通,则不能构成最小生成树。
if(i) res+=d[t]; //从第二个点开始将计算边长和
st[t]=true; //t点已经在连通块中,标记。
for(int j=1;j<=n;j++) //用t点更新连通块儿以外的点距离连通块的最小距离。
d[j]=min(d[j],a[t][j]);
}
return res;
}
int main()
{
cin>>n>>m;
memset(a,0x3f,sizeof a);
for(int i=1;i<=i;i++) a[i][i]=0;
while(m--)
{
int x,y,z;
cin>>x>>y>>z;
a[x][y]=a[y][x]=min(a[x][y],z); //重边取最小值。
}
int t=prim();
if(t==INF) puts("impossible");
else printf("%d",res);
return 0;
}
堆优化Prim算法
参考 Dijkstra的堆优化
#include<bits/stdc++.h>
using namespace std;
const int N = 510,M=2*100010,INF=0x3f3f3f3f; //用邻接表存储无向图,边集空间开两倍
typedef pair<int,int> PII;
int n,m;
int h[N],e[M],w[M],ne[M],idx;
int st[N],res,cnt; //cnt记录已经有多少点存入连通块儿中。
void add(int x,int y,int z)
{
e[idx]=y,w[idx]=z,ne[idx]=h[x],h[x]=idx++;
}
int prim()
{
priority_queue<PII,vector<PII>,greater<PII> > heap;
heap.push({0,1}); //以1号点为起点,堆中维护着点到联通块儿的距离和点值
while(heap.size())
{
auto t=heap.top(); //取出堆顶距离连通块儿距离最近的点
heap.pop();
int ver=t.second,dis=t.first;
if(st[ver]) continue; //如果点已经在连通块儿中直接跳过
//标记距离连通块儿最近的点
st[ver]=1;
res+=dis;
cnt++;
for(int i=h[ver];i!=-1;i=ne[i]) //利用该点更新剩余点到连通块儿的距离。更新方法,将所有能够到达的点都加入堆中,因为堆只取堆顶最小的,所以无所谓重复点加入。
{
int j=e[i];
if(!st[j])
heap.push({w[i],j});
}
}
if(cnt!=n) return INF;
return res;
}
int main()
{
cin>>n>>m;
memset(h,-1,sizeof h);
while(m--)
{
int x,y,z;
scanf("%d%d%d",&x,&y,&z);
if(x!=y) //构造最小生成树不看自环,所以自环直接不添加。
add(x,y,z),add(y,x,z);
}
int t=prim();
if(t==INF) puts("impossible");
else printf("%d",t);
return 0;
}
通常在求解最小生成树时,如果是稠密图则使用朴素Prim算法,如果是稀疏图则使用Kruskal算法。