第十三章 最小生成树

6
1 5 1 3
(2,5) (3,6)
4
2 3
(1,4) (3,4)
4
5 6
2
最小代价生成树
(2,3)
添加
{1,3,4,5,6,2}
算法难点及解决方案

如何从所有边中选择代价最小的边：边放入一个优先级 队列，边的优先级就是它的权值。权值越小，优先级越 高。 用并查集来实现。将一个连通分量表示为并查集中的一 个子集，检查一条边加入后会不会形成回路可以通过对 边的两个端点分别执行Find操作。如果两个Find的结果相 同，则表示两个端点已连通，加入这条边会形成回路， 否则将这条边加入生成树。添加边的操作就是一个 Union 操作，将两个端点所属的子集归并起来，表示其中的所 有顶点都已连通。

第13章 最小生成树


生成树与最小生成树 Kruskal算法 Prim算法 算法的正确性
Kruscal 算法


基本思想：考虑图中权值最小的边。如果 加入这条边不会导致回路，则加入；否则 考虑下一条边，直到包含了所有的顶点 实现：
初始时，设置生成树为（V，Φ），如果V有n 个顶点，则初始的生成树为具有n个连通分量的 树。 按权值的大小逐个考虑所有的边，如果该边的 加入能连接两个连通分量，则加入。当生成树 只有一个连通分量时，算法结束。
kruskal算法的实现
template <class TypeOfVer, class TypeOfEdge> void adjListGraph<TypeOfVer, TypeOfEdge>::kruskal( ) const { int edgesAccepted = 0，u, v; edgeNode *p; edge e; DisjointSet ds( Vers ); //定义一个并查集 priorityQueue<edge> pq; //定义一个关于边的优先级队列
无向图G A E H M C D C B 无向图G的生成树 A E H M D B
最小生成树 (Minimum spanning tree, MST)

定义：加权无向图的所有生成树中边的权值（代价） 之和最小的树。
最小代价生成树
1 6 2 5 6 5 1 3 4 5 5 4 2 3 5 5 1 1 3 4 6 4 2
3
2
6
6
Application: Network design
Applications

MST is fundamental problem with diverse applications.
Dithering. Cluster analysis. Max bottleneck paths. Real-time face verification. LDPC codes for error correction. Image registration with Renyi entropy. Find road networks in satellite and aerial imagery. Reducing data storage in sequencing amino acids in a protein. Model locality of particle interactions in turbulent fluid flows. Autoconfig protocol for Ethernet bridging to avoid cycles in a network. Approximation algorithms for NP-hard problems (e.g., TSP, Steiner tree). Network design (communication, electrical, hydraulic, computer, road). /~eppstein/gina/mst.html

1 6 2 3 5 5 6 1 3 4 5 5 4 2 6
1、初始连通分量： {1},{2},{3},{4},{5},{6}
2、反复执行添加、放弃动作。
边
(1,3) (4,6)
动作
添加 添加 添加 添加 放弃 放弃
连通分量
{1,3},{4},{5},{6},{2} {1,3},{4, 6},{2},{5} {1,3},{4, 6},{2,5} {1,3,4, 6},{2,5} 因构成回路 因构成回路
prim算法运行过程中startNode和 lowCost数组的变化
编号
0 6 1 3 4 5 6 6 1 2 4 5 5 5 3 2
startNode
lowCost
编号
visited
0
1 2 3 4 5
随机值
20 随机值 随机值 0 随机值 2 5 0 25 1 随机值 随机值 2
∞
6 ∞ 5 1 ∞ 5∞ 2 5 ∞ 3 6 4 ∞
第13章 最小生成树


生成树与最小生成树 Kruskal算法 Prim算法 算法的正确性
Prim算法


从顶点的角度出发。初始时，顶点集U为空，然 后逐个加入顶点，直到包含所有顶点。 过程：首先选择一个顶点，加入顶点集。然后重 复下列工作，直到U = V


选择连接U 和V-U 中代价最小的边（u，v） 把（u，v）加入生成树的边集，v加入到U

如何判断加入一条边后会不会形成回路：

定义优先级队列中的元素类型
struct edge { int beg, end; //边的起点、终点和权值 TypeOfEdge w; bool operator<(const edge &rp) const {return w < rp.w;} //重载小于运算符 };
start = 0; //将0作为第一个加入U中结点 for ( i= 1; i < Vers; ++i) { //共找n-1条边, 检查start的边，对于start的每一条
边(start, v)，如果v不在生成树中，并且边的权值w小于lowCost[v]时更新
for (p = verList[start].head; p != NULL; p = p->next) if (!flag[p->end] && lowCost[p->end] > p->weight) { lowCost[p->end] = p->weight; //更新距离 startNode[p->end] = start; } flag[start] = true; //将start加入U中 min = noEdge; for (j = 0; j < Vers; ++j) //寻找权值最小的边 if (lowCost[j] < min) {min = lowCost[j]; start = j;} //将j加入U cout << '(' << verList[startNode[start]].ver << ',‘ << verList[start].ver << ")\t"; lowCost[start] = noEdge; //不再考虑这条边 } delete [ ] flag; delete [ ] startNode; delete [ ] lowCost; }
//将所有的边放入优先级队列
for (int i = 0; i< Vers; ++i) { for (p = verList[i].head; p != NULL; p = p->next) if (i < p->end) { //每条边只入队一次 e.beg = i; e.end = p->end; e.w = p->weight; pq.enQueue(e); } }
数据结构 Data Structure
第十三章 最小生成树
第13章 最小生成树


生成树与最小生成树 Kruskal算法 Prim算法 算法的正确性
生成树

生成树是无向连通图的极小连通子图。包含图的 所有 n 个结点，但只含图的 n-1 条边。在生成树 中添加一条边之后，必定会形成回路或环。
flag[i]=ture 表示结点i在U中，否则表示结点i不在U中。 //用两个一维数组lowCost和startNode来记录U中的结点到V-U中结点的 权值最小的边。 TypeOfEdge *lowCost = new TypeOfEdge[Vers]; //表示U中的结 点到结点i的边的最小权值。 int *startNode = new int[Vers]; //表示从U中的哪一个结点出发到结 点i的权值是lowCost[i]。
时间复杂度



生成优先级队列的for循环将所有的边入队。需要 执行|E|次入队，建堆时间为log|E|, 生成优先级队 列所需时间是O(|E|log|E|)。 在最坏的情况下，归并的循环可能需要检查所有 的边。对于每条边，最多需要执行两次Find操作 和一次Union操作。因此，归并循环的最坏情况的 时间复杂度是O(|E|log|V|)。 在一个连通图中，一般边数总比结点数大，所以， Kruskal算法的时间复杂度是O(E|log|E|)。
//开始归并
while( edgesAccepted < Vers - 1 ) //选择边数不满n-1时 { e = pq.deQueue(); //取出权值最小的边 u = ds.Find(e.beg); v = ds.Find(e.end); if( u != v ) //边的起点和终点在不同的连通子图 { edgesAccepted++; ds.Union( u, v ); //加入(u,v)归并两个连通子图 cout << '(' << verList[e.beg].ver << ',' << verList[e.end].ver << ")\t"; } } }