最小生成树 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).初始化:V new= {x},其中x为集合V中的任一节点(起始点),E new= {},为空;
3).重复下列操作,直到V new= V:
a.在集合E中选取权值最小的边,其中u为集合V new中的元素,而v不在V new集合当中,并且v∈V(如果存在有多条满足前述条件即具有相同权值的边,则可任意选取其中之一);
b.将v加入集合V new中,将边加入集合E new中;
4).输出:使用集合V new和E new来描述所得到的最小生成树。

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]
Prim+heap二叉堆优化
#include 
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算法分析:

使用邻接矩阵来保存图的话,时间复杂度是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 
#include 
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;ivexs[i]=0;
    for(i=0;iarcs[i][j]=INFINITY;
}

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

    for(int i=0;iarcnum;i++)
    {    
        cin>>ch1>>ch2>>weight;
        for(int j=0;jvexnum;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;ivexnum;i++)
        cout<<"   "<vexs[i]<<"  ";
    cout<vexnum;i++)
    {
        cout<vexs[i];
        for(int j=0;jvexnum;j++)
        {
            cout<arcs[i][j]<<" ";
        }
        cout<vexnum;i++)
     set[i]=i;

   printf("最小代价生成树的各条边为:\n");
   while(kvexnum-1)
   {
     for(i=0;ivexnum;++i)
       for(j=i+1;jvexnum;++j)
           if(g->arcs[i][j]arcs[i][j];
                 a=i;
                 b=j;
           }
     min=g->arcs[a][b]=INFINITY;
     if(set[a]!=set[b])
     {
       cout<vexs[a]<<"  "<vexs[b]<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算法效率分析


最小生成树 Prim以及Kruskal算法及效率解析_第1张图片

最小生成树 Prim以及Kruskal算法及效率解析_第2张图片

最小生成树 Prim以及Kruskal算法及效率解析_第3张图片

最小生成树 Prim以及Kruskal算法及效率解析_第4张图片

最小生成树 Prim以及Kruskal算法及效率解析_第5张图片





通过上图可以看出:

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

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

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

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


你可能感兴趣的:(ACM)