最小生成树 Prim以及Kruskal算法及效率解析

生成树：

      一个有 n 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有
n 个结点，并且有保持图连通的最少的边。

最小生成树：

   在一给定的无向图G
= (V, E) 中，(u, v) 代表连接顶点 u 与顶点 v 的边（即），而 w(u, v) 代表此边的权重，若存在
T 为 E 的子集（即）且为无循环图，使得

的 w(T) 最小，则此 T 为 G 的最小生成树。

最小生成树其实是最小权重生成树的简称。

算法：

Prim算法简述

1).输入：一个加权连通图，其中顶点集合为V，边集合为E；

2).初始化：Vnew= {x}，其中x为集合V中的任一节点（起始点），Enew= {},为空；

3).重复下列操作，直到Vnew= V：

a.在集合E中选取权值最小的边<u, v>，其中u为集合Vnew中的元素，而v不在Vnew集合当中，并且v∈V（如果存在有多条满足前述条件即具有相同权值的边，则可任意选取其中之一）；

b.将v加入集合Vnew中，将<u, v>边加入集合Enew中；

4).输出：使用集合Vnew和Enew来描述所得到的最小生成树。

Prim邻接矩阵代码

int N,dis[MAX+10][MAX+10];//点的个数及每两个点之间的距离
int prim()
{
int s=1;//源点,最开始为第一个
int num=1;//已加入MST的点的个数,用于判断循环是否结束
int sum_w=0;//MST的权值和
int min_w;//每次加入MST的边的权值
int flag;//与MST中点形成符合prim规则的不在MST中的点的序号
int low_dis[MAX+5];//每个源点到其他味加入MST的点的最短距离
bool uni[MAX+5];//标记点是否已经加入MST
memset(uni,false;sizeof(uni));
memset(low_dis;INF;sizeof(low_dis));
uni[s]=true;
while(1)
{
if(num==N) break;
min_w=INF;
for(int i=2;i<=N;i++)
{
if(!uni[i]&&dis[i][s]<low_dis[i])
low_dis[i]=dis[i][s];
if(!uni[i]&&low_dis[i]<min_w)
{
min_w=low_dis[i];
flag=i;
}
}
s=flag;//更新源点
u[s]=true;
sum_w+=min_w;
num++;
}
return sum_w;
}

Prim+heap二叉堆优化

#include <iostream>
using namespace std;
const int MAXV = 10001, MAXE = 100001, INF = (~0u)>>2;
struct edge{
int t, w, next;
}es[MAXE * 2];
int h[MAXV], cnt, n, m, heap[MAXV], size, pos[MAXV], dist[MAXV];
void addedge(int x, int y, int z)
{
es[++cnt].t = y;
es[cnt].next = h[x];
es[cnt].w = z;
h[x] = cnt;
}
void heapup(int k)
{
while(k > 1){
if(dist[heap[k>>1]] > dist[heap[k]]){
swap(pos[heap[k>>1]], pos[heap[k]]);
swap(heap[k>>1], heap[k]);
k>>=1;
}else
break;
}
}
void heapdown(int k)
{
while((k<<1) <= size){
int j;
if((k<<1) == size || dist[heap[(k<<1)]] < dist[heap[(k<<1)+1]])
j = (k<<1);
else
j = (k<<1) + 1;
if(dist[heap[k]] > dist[heap[j]]){
swap(pos[heap[k]], pos[heap[j]]);
swap(heap[k], heap[j]);
k=j;
}else
break;
}
}
void push(int v, int d)
{
dist[v] = d;
heap[++size] = v;
pos[v] = size;
heapup(size);
}
int pop()
{
int ret = heap[1];
swap(pos[heap[size]], pos[heap[1]]);
swap(heap[size], heap[1]);
size--;
heapdown(1);
return ret;
}
int prim()
{
int mst = 0, i, p;
push(1, 0);
for(i=2; i<=n; i++)
push(i, INF);
for(i=1; i<=n; i++){
int t = pop();
mst += dist[t];
pos[t] = -1;
for(p = h[t]; p; p = es[p].next){
int dst = es[p].t;
if(pos[dst] != -1 && dist[dst] > es[p].w){
dist[dst] = es[p].w;
heapup(pos[dst]);
heapdown(pos[dst]);
}
}
}
return mst;
}
int main()
{
cin>>n>>m;
for(int i=1; i<=m; i++){
int x, y, z;
cin>>x>>y>>z;
addedge(x, y, z);
addedge(y, x, z);
}
cout<<prim()<<endl;
return 0;
}

Prim算法分析:

使用邻接矩阵来保存图的话，时间复杂度是O(N^2)，观察代码很容易发现，时间主要浪费在每次都要遍历所有点找一个最小距离的顶点，对于这个操作，我们很容易想到用堆来优化，使得每次可以在log级别的时间找到距离最小的点。下面的代码是一个使用二叉堆实现的堆优化Prim算法，代码使用邻接表来保存图。另外，需要说明的是，为了松弛操作的方便， 堆里面保存的顶点的标号，而不是到顶点的距离，所以我们还需要维护一个映射pos[x]表示顶点x在堆里面的位置。

使用二叉堆优化Prim算法的时间复杂度为O((V + E) log(V)) = O(E log(V))，对于稀疏图相对于朴素算法的优化是巨大的，然而100行左右的二叉堆优化Prim相对于40行左右的并查集优化Kruskal，无论是在效率上，还是编程复杂度上并不具备多大的优势。另外，我们还可以用更高级的堆来进一步优化时间界，比如使用斐波那契堆优化后的时间界为O(E + V log(V))，但编程复杂度也会变得更高。

Kruskal算法简述

假设 WN=(V,{E}) 是一个含有 n 个顶点的连通网，则按照克鲁斯卡尔算法构造最小生成树的过程为：先构造一个只含 n 个顶点，而边集为空的子图，若将该子图中各个顶点看成是各棵树上的根结点，则它是一个含有 n 棵树的一个森林。之后，从网的边集
E 中选取一条权值最小的边，若该条边的两个顶点分属不同的树，则将其加入子图，也就是说，将这两个顶点分别所在的两棵树合成一棵树；反之，若该条边的两个顶点已落在同一棵树上，则不可取，而应该取下一条权值最小的边再试之。依次类推，直至森林中只有一棵树，也即子图中含有 n-1条边为止。
Kruskal邻接矩阵

#include <iostream>
#include <iomanip>
using namespace std;

#define MAX_VERTEX_NUM    10        //最大顶点个数
#define INFINITY 32768
typedef char VerType;
typedef int VRType;
typedef struct
{
VerType    vexs[MAX_VERTEX_NUM];    //顶点向量
int        arcs[MAX_VERTEX_NUM][MAX_VERTEX_NUM];                    //邻接矩阵
int        vexnum,arcnum;            //图的当前顶点数和弧数
}mgraph, * MGraph;

//初始化图
void init_mgraph(MGraph &g)
{
g=(MGraph)malloc(sizeof(mgraph));
g->vexnum=0;
g->arcnum=0;
for(int i=0;i<MAX_VERTEX_NUM;i++)
g->vexs[i]=0;
for(i=0;i<MAX_VERTEX_NUM;i++)
for(int j=0;j<MAX_VERTEX_NUM;j++)
g->arcs[i][j]=INFINITY;
}

void add_vexs(MGraph &g)    //增加顶点
{
cout<<"请输入顶点的个数:"<<endl;
cin>>g->vexnum;
cout<<"请输入顶点的值"<<endl;
for(int i=0;i<g->vexnum;i++)
{
cin>>g->vexs[i];
}
}
void add_arcs(MGraph &g)    //增加边
{
cout<<"请输入边的个数:"<<endl;
cin>>g->arcnum;
VerType ch1,ch2;
int weight;
int row,col;

for(int i=0;i<g->arcnum;i++)
{
cin>>ch1>>ch2>>weight;
for(int j=0;j<g->vexnum;j++)
{
if(g->vexs[j]==ch1)
{
row=j;
}
if(g->vexs[j]==ch2)
{
col=j;
}
}
g->arcs[row][col]=weight;    //有向带权图只需把1改为weight
g->arcs[col][row]=weight;
}
}
void creat_mgraph(MGraph &g) //创建图
{
add_vexs(g);    //增加顶点
add_arcs(g);    //增加边
}

void print_mgraph(MGraph &g) //打印图
{
for(int i=0;i<g->vexnum;i++)
cout<<"   "<<g->vexs[i]<<"  ";
cout<<endl;
for(i=0;i<g->vexnum;i++)
{
cout<<g->vexs[i];
for(int j=0;j<g->vexnum;j++)
{
cout<<setw(5)<<g->arcs[i][j]<<" ";
}
cout<<endl;
}
}

//克鲁斯卡尔算法
void MiniSpanTree_Kruskal(MGraph &g, VerType u)    //普里姆算法从顶点u出发构造G的最小生成树T，输出T的各条边。
{
int set[MAX_VERTEX_NUM],i,j;

int k=0,a=0,b=0,min=INFINITY;

for(i=0;i<g->vexnum;i++)
set[i]=i;

printf("最小代价生成树的各条边为:\n");
while(k<g->vexnum-1)
{
for(i=0;i<g->vexnum;++i)
for(j=i+1;j<g->vexnum;++j)
if(g->arcs[i][j]<min)
{
min=g->arcs[i][j];
a=i;
b=j;
}
min=g->arcs[a][b]=INFINITY;
if(set[a]!=set[b])
{
cout<<g->vexs[a]<<"  "<<g->vexs[b]<<endl;
k++;
for(i=0;i<g->vexnum;i++)
{
if(set[i]==set[b] && i!=b)    //i!=b，set[b]不能变为set[a],如果变了后面的和set[b]一样的就变不了
set[i]=set[a];
}
set[b]=set[a];    //其它的都变了之后，再改变set[b]
}
}
}//MiniSpanTree_Kruskal

int main()
{
MGraph G;
init_mgraph(G);        //初始化图
creat_mgraph(G);    //创建图
print_mgraph(G);    //打印图
MiniSpanTree_Kruskal(G,G->vexs[0]);    //最小生成树

return 0;
}

另外，附上Prim，Prim+heap，Kruskal算法效率分析











通过上图可以看出：

1.Prim在稠密图中比Kruskal优，在稀疏图中比Kruskal劣。

2.Prim+Heap在任何时候都有令人满意的的时间复杂度，但是代价是空间消耗极大。【以及代码很复杂>_<】

3.时间复杂度并不能反映出一个算法的实际优劣。

竞赛所给的题大多数是稀疏图，所以尽可能地使用Prim+Heap吧，在稀疏图中这是无敌的。如果一定要在朴素Prim和Kruskal里选一个的话那就用Kruskal吧。当然Prim的代码比较简单，对付水题用Prim也无所谓，只要不是极稀疏图两者相差不大