第1行：2个数N,M中间用空格分隔，N为点的数量，M为边的数量。（2 <= N <= 1000, 1 <= M <= 50000) 第2 - M + 1行：每行3个数S E W，分别表示M条边的2个顶点及权值。(1 <= S, E <= N，1 <= W <= 10000)
输出最小生成树的所有边的权值之和。
9 14 1 2 4 2 3 8 3 4 7 4 5 9 5 6 10 6 7 2 7 8 1 8 9 7 2 8 11 3 9 2 7 9 6 3 6 4 4 6 14 1 8 8
37
prim算法实现过程#include<iostream>
#include<cstdio>
#include<map>
#include<cstring>
#include<string>
#include<algorithm>
#include<queue>
#include<vector>
#include<stack>
#include<cstdlib>
#include<cctype>
#include<cstring>
#include<cmath>
using namespace std;
const int inf =0x3f3f3f3f;
int G[1001][1001];
int vis[1001],lowc[1001]; //lowc数组临时储存待选变量，vis数组用于给点做标记是否选中
int prim(int G[][1001],int n){
int i,j,p,minc,res=0;
memset(vis,0,sizeof(vis));
vis[1]=1; //从第一个顶点开始遍历
for(i = 2; i <= n; i++){
lowc[i]=G[1][i]; //临时储存找最短边的一些变量
}
for(i = 2; i <= n ;i++){
minc=inf; //用于标记最短点
p=-1; //用于标记点的座标
for(j = 1; j <= n;j++){
if(vis[j]==0&&lowc[j]<minc){
minc=lowc[j];
p=j;
}
}
if(inf==minc)return -1; //原图不连通
res+=minc;
vis[p]=1; //点选择过了就标记为1
for(j = 1; j<=n ;j++){ //按照上面找到的最短边进行接下来的寻找
if(vis[j]==0&&lowc[j]>G[p][j]){ //如果点未被选择过，且lowc里面的比矩阵里面的大
lowc[j]=G[p][j];
}
}
}
return res;
}
int main()
{
int n,m;
while(cin>>n>>m)// n点的个数，m边的个数
{
int x,y,w;
memset(G,inf,sizeof(G));
for(int i = 0;i < m;i++){
cin>>x>>y>>w;
G[x][y]=G[y][x]=w; //无向图权值对称
}
cout<<prim(G,n)<<endl;
}
}下面给出了最小生成树的两种算法的原理：
给定一个带权的无向连通图,如何选取一棵生成树,使树上所有边上权的总和为最小,这叫最小生成树.
求最小生成树的算法
(1) 克鲁斯卡尔算法
图的存贮结构采用边集数组,且权值相等的边在数组中排列次序可以是任意的.该方法对于边相对比较多的不是很实用,浪费时间.
(2) 普里姆算法
图的存贮结构采用邻接矩阵.此方法是按各个顶点连通的步骤进行,需要用一个顶点集合,开始为空集,以后将以连通的顶点陆续加入到集合中,全部顶点加入集合后就得到所需的最小生成树 .
下面来具体讲下：
克鲁斯卡尔算法
方法:将图中边按其权值由小到大的次序顺序选取,若选边后不形成回路,则保留作为一条边,若形成回路则除去.依次选够(n-1)条边,即得最小生成树.(n为顶点数)
第一步:由边集数组选第一条边
第二步:选第二条边,即权值为2的边
第三步:选第三条边,即权值为3的边
第四步:选第四条边,即权值为4的边
第五步:选第五条边
普里姆算法
方法:从指定顶点开始将它加入集合中,然后将集合内的顶点与集合外的顶点所构成的所有边中选取权值最小的一条边作为生成树的边,并将集合外的那个顶点加入到集合中,表示该顶点已连通.再用集合内的顶点与集合外的顶点构成的边中找最小的边,并将相应的顶点加入集合中,如此下去直到全部顶点都加入到集合中,即得最小生成树.
例在下图中从1点出发求出此图的最小生成树,并按生成树的边的顺序将顶点与权值填入表中.
———————>先写出其邻接矩阵
第一步:从①开始，①进集合，用与集合外所有顶点能构成的边中找最小权值的一条边
①——②权6
①——③权1 -> 取①——③边
①——④权5
第二步:③进集合，①，③与②,④,⑤,⑥构成的最小边为
①——④权5
③——⑥权4 -> 取③——⑥边
第三步:⑥进集合，①，③,⑥与②,④,⑤构成的各最小边
①——②权6
③——②权5
⑥——④权2 -> 取⑥——④边
第四步:④进集合，①，③,⑥,④与②,⑤构成的各最小边
①——②权6
③——②权5 -> 取③——②边
⑥——⑤权6
第四步:②进集合，①，③,⑥,②,④与⑤构成的各最小边
②——⑤权3 -> 取②——⑤边
这也是在网上找到的一个Kruskal和Prim构造过程图，贴出来：
Kruskal算法
typedef struct
{
char vertex[VertexNum]; //顶点表
int edges[VertexNum][VertexNum]; //邻接矩阵,可看做边表
int n,e; //图中当前的顶点数和边数
}MGraph;
typedef struct node
{
int u; //边的起始顶点
int v; //边的终止顶点
int w; //边的权值
}Edge;
void kruskal(MGraph G)
{
int i,j,u1,v1,sn1,sn2,k;
int vset[VertexNum]; //辅助数组，判定两个顶点是否连通
int E[EdgeNum]; //存放所有的边
k=0; //E数组的下标从0开始
for (i=0;i<G.n;i++)
{
for (j=0;j<G.n;j++)
{
if (G.edges[i][j]!=0 && G.edges[i][j]!=INF)
{
E[k].u=i;
E[k].v=j;
E[k].w=G.edges[i][j];
k++;
}
}
}
heapsort(E,k,sizeof(E[0])); //堆排序，按权值从小到大排列
for (i=0;i<G.n;i++) //初始化辅助数组
{
vset[i]=i;
}
k=1; //生成的边数，最后要刚好为总边数
j=0; //E中的下标
while (k<G.n)
{
sn1=vset[E[j].u];
sn2=vset[E[j].v]; //得到两顶点属于的集合编号
if (sn1!=sn2) //不在同一集合编号内的话，把边加入最小生成树
{
printf("%d ---> %d, %d",E[j].u,E[j].v,E[j].w);
k++;
for (i=0;i<G.n;i++)
{
if (vset[i]==sn2)
{
vset[i]=sn1;
}
}
}
j++;
}
}