最小生成树问题

基本概念

最小生成树

• 是一棵树
  • 无回路，向生成树中任加一条边都一定构成回路
  • |V|个顶点一定有|V|-1条边
• 是生成树
  • 包含全部顶点
  • |V|-1条边都在图里
• 边的权重最小

贪心算法

对于如何最小生成树的算法，我们使用贪心算法。

• 什么是“贪”：每一步都要好的
• 什么是“好”：权重最小的边
• 需要约束
  • 只能用图里有的边
  • 只能正好用掉|V|-1条边
  • 不能有回路

Prim算法

类似Dijkstra算法

Vertex FindMinDist(MGraph Graph, WeightType dist[]){		//返回未被收录顶点中dist最小者
	Vertex MinV,V;
	WeightType MinDist=INFINITY;

	for(V=0;V<Graph->Nv;V++){		//对于图中每个顶点V
		if(dist[V]!=0&&dist[V]<MinDist){		//若V未被收录且dist[V]更小
			MinDist=dist[V];		//更新最小距离
			MinV=V;			//更新对应顶点
		}
	}
	if(MinDist<INFINITY)
		return MinV;
	else
		return false;
}

int Prim(MGraph Graph, LGraph MST){		//将最小生成树保存为邻接表存储的图MST，返回最小权重和
	WeightType dist[MaxVertexNum],TotalWeight;
	Vertex parent[MaxVertexNum],V,W;
	int VCount;
	Edge E;

	for(V=0;V<Graph->Nv;V++){		//初始化，默认初始顶点下标为0
		dist[V]=Graph->G[0][V];
		parent[V]=0;
	}
	TotalWeight=0;
	VCount=0;

	MST=CreateGraph(Graph->Nv);		//创建包含所有顶点但没有边的邻接表存储的图
	E=(Edge)malloc(sizeof(struct ENode));		//建立空的边结点

	dist[0]=0;
	VCount++;
	parent[0]=-1;

	while(1){
		V=FindMinDist(Graph, dist);		//找到未被收录顶点中dist最小者
		if(V==ERROR)
			break;
		E->V1=parent[V];		//将V及相应的边<parent[V],V>收录进MST
		E->V2=V;
		E->Weight=dist[V];
		InsertEdge(MST,E);
		TotalWeight+=dist[V];
		dist[V]=0;
		VCount++;

		for(W=0;W<Graph->Nv;W++)
			if(dist[W]!=0&&Graph->G[V][W]<INFINITY){		//若W未被收录且W是V的邻接点
				if(Graph->G[V][W]<dist[W]){		//收录进V使得dist[W]变小
					dist[W]=Graph->G[V][W];		//更新dist[W]
					parent[W]=V;		//更新树
				}
			}	
	}
	if(VCount<Graph->Nv)		//MST中的顶点不到|V|个
		TotalWeight=ERROR;
	return TotalWeight;
}

对于稠密图，时间复杂度T=O(|V|^2)

Kruskal算法

Kruskal算法是将森林合并成树。
伪代码如下：

void Kruskal(Graph G){
	MST={ };
	while(MST中不到|V|-1条边 && E中还有边){
		从E中取一条权重最小的边E(V,W);		//最小堆
		将E(V,W)从E中删除;
		if(E(V,W)不在MST中构成回路)		//并查集
			将E(V,W)加入MST;
		else
			彻底无视E(V,W);
	}
	if(MST中不到|V|-1条边)
		ERROR("生成树不存在");
}

C语言代码如下，摘自浙大陈越奶奶数据结构：

/* 邻接表存储 - Kruskal最小生成树算法 */
 
/*-------------------- 顶点并查集定义 --------------------*/
typedef Vertex ElementType; /* 默认元素可以用非负整数表示 */
typedef Vertex SetName;     /* 默认用根结点的下标作为集合名称 */
typedef ElementType SetType[MaxVertexNum]; /* 假设集合元素下标从0开始 */
 
void InitializeVSet( SetType S, int N )
{ /* 初始化并查集 */
    ElementType X;
 
    for ( X=0; X<N; X++ ) S[X] = -1;
}
 
void Union( SetType S, SetName Root1, SetName Root2 )
{ /* 这里默认Root1和Root2是不同集合的根结点 */
    /* 保证小集合并入大集合 */
    if ( S[Root2] < S[Root1] ) { /* 如果集合2比较大 */
        S[Root2] += S[Root1];     /* 集合1并入集合2  */
        S[Root1] = Root2;
    }
    else {                         /* 如果集合1比较大 */
        S[Root1] += S[Root2];     /* 集合2并入集合1  */
        S[Root2] = Root1;
    }
}
 
SetName Find( SetType S, ElementType X )
{ /* 默认集合元素全部初始化为-1 */
    if ( S[X] < 0 ) /* 找到集合的根 */
        return X;
    else
        return S[X] = Find( S, S[X] ); /* 路径压缩 */
}
 
bool CheckCycle( SetType VSet, Vertex V1, Vertex V2 )
{ /* 检查连接V1和V2的边是否在现有的最小生成树子集中构成回路 */
    Vertex Root1, Root2;
 
    Root1 = Find( VSet, V1 ); /* 得到V1所属的连通集名称 */
    Root2 = Find( VSet, V2 ); /* 得到V2所属的连通集名称 */
 
    if( Root1==Root2 ) /* 若V1和V2已经连通，则该边不能要 */
        return false;
    else { /* 否则该边可以被收集，同时将V1和V2并入同一连通集 */
        Union( VSet, Root1, Root2 );
        return true;
    }
}
/*-------------------- 并查集定义结束 --------------------*/
 
/*-------------------- 边的最小堆定义 --------------------*/
void PercDown( Edge ESet, int p, int N )
{ /* 改编代码4.24的PercDown( MaxHeap H, int p )    */
  /* 将N个元素的边数组中以ESet[p]为根的子堆调整为关于Weight的最小堆 */
    int Parent, Child;
    struct ENode X;
 
    X = ESet[p]; /* 取出根结点存放的值 */
    for( Parent=p; (Parent*2+1)<N; Parent=Child ) {
        Child = Parent * 2 + 1;
        if( (Child!=N-1) && (ESet[Child].Weight>ESet[Child+1].Weight) )
            Child++;  /* Child指向左右子结点的较小者 */
        if( X.Weight <= ESet[Child].Weight ) break; /* 找到了合适位置 */
        else  /* 下滤X */
            ESet[Parent] = ESet[Child];
    }
    ESet[Parent] = X;
}
 
void InitializeESet( LGraph Graph, Edge ESet )
{ /* 将图的边存入数组ESet，并且初始化为最小堆 */
    Vertex V;
    PtrToAdjVNode W;
    int ECount;
 
    /* 将图的边存入数组ESet */
    ECount = 0;
    for ( V=0; V<Graph->Nv; V++ )
        for ( W=Graph->G[V].FirstEdge; W; W=W->Next )
            if ( V < W->AdjV ) { /* 避免重复录入无向图的边，只收V1<V2的边 */
                ESet[ECount].V1 = V;
                ESet[ECount].V2 = W->AdjV;
                ESet[ECount++].Weight = W->Weight;
            }
    /* 初始化为最小堆 */
    for ( ECount=Graph->Ne/2; ECount>=0; ECount-- )
        PercDown( ESet, ECount, Graph->Ne );
}
 
int GetEdge( Edge ESet, int CurrentSize )
{ /* 给定当前堆的大小CurrentSize，将当前最小边位置弹出并调整堆 */
 
    /* 将最小边与当前堆的最后一个位置的边交换 */
    Swap( &ESet[0], &ESet[CurrentSize-1]);
    /* 将剩下的边继续调整成最小堆 */
    PercDown( ESet, 0, CurrentSize-1 );
 
    return CurrentSize-1; /* 返回最小边所在位置 */
}
/*-------------------- 最小堆定义结束 --------------------*/
 
 
int Kruskal( LGraph Graph, LGraph MST )
{ /* 将最小生成树保存为邻接表存储的图MST，返回最小权重和 */
    WeightType TotalWeight;
    int ECount, NextEdge;
    SetType VSet; /* 顶点数组 */
    Edge ESet;    /* 边数组 */
 
    InitializeVSet( VSet, Graph->Nv ); /* 初始化顶点并查集 */
    ESet = (Edge)malloc( sizeof(struct ENode)*Graph->Ne );
    InitializeESet( Graph, ESet ); /* 初始化边的最小堆 */
    /* 创建包含所有顶点但没有边的图。注意用邻接表版本 */
    MST = CreateGraph(Graph->Nv);
    TotalWeight = 0; /* 初始化权重和     */
    ECount = 0;      /* 初始化收录的边数 */
 
    NextEdge = Graph->Ne; /* 原始边集的规模 */
    while ( ECount < Graph->Nv-1 ) {  /* 当收集的边不足以构成树时 */
        NextEdge = GetEdge( ESet, NextEdge ); /* 从边集中得到最小边的位置 */
        if (NextEdge < 0) /* 边集已空 */
            break;
        /* 如果该边的加入不构成回路，即两端结点不属于同一连通集 */
        if ( CheckCycle( VSet, ESet[NextEdge].V1, ESet[NextEdge].V2 )==true ) {
            /* 将该边插入MST */
            InsertEdge( MST, ESet+NextEdge );
            TotalWeight += ESet[NextEdge].Weight; /* 累计权重 */
            ECount++; /* 生成树中边数加1 */
        }
    }
    if ( ECount < Graph->Nv-1 )
        TotalWeight = -1; /* 设置错误标记，表示生成树不存在 */
 
    return TotalWeight;
}

时间复杂度T=O(|E|log|E|)