重拾算法(5)——最小生成树的两种算法及其对比测试

重拾算法(5)——最小生成树的两种算法及其对比测试

什么是最小生成树

求解最小生成树(Minimum Cost Spanning Tree，以下简写做MST）是图相关的算法中常见的一个，用于解决类似如下的问题：

假设要在N个城市之间建立通信联络网，那么连通N个城市只需N-1条线路。这时自然会考虑这样一个问题：如何在最节省经费的前提下建立这个通信网。

在任意两个城市间都可以设置一条线路，相应地都要付出一定的经济代价。N个城市之间最多可能设置N(N-1)/2条线路，那么如何在这些线路中选择N-1条，以使总的耗费最少呢？

可以用连通图来表示N个城市，顶点表示城市，通信线路就是带有权值的边。一般而言，一个连通图有多个生成树，这些生成树的总的权值不同，其中会有1或多个的总权值最小，这1或多个生成树就是我们要求解的MST。（只需求出其中一个即可）

本篇介绍两种求解MST的算法：Prim和Kruskal，然后测试之。

Prim算法

现在有一个连通图G，要求MST，我们把G中的顶点划分到U、V两个集合里，假设我们已经知道了MST在U范围内的连接方式，（为什么做这种假设？只可意会不可言传）尚未获知MST在V范围内的连接方式，也不知道MST在U、V之间的连接方式。

现在，我们有办法求得U、V之间的连接方式了：从U、V中分别任取一个顶点（记作u、v），我们知道这有多种取法。U中的顶点有其MST-U，V也有MST-V，而边u-v将MST-U和MST-V的各个顶点都联系起来了，所以MST-U、u-v、MST-V三者就构成了一个生成树ST，而当边u-v是所有取法中最小的那个时，ST自然就是MST了。

整理一下，就是Prim算法的思路：初始时随便取一个顶点vertex作为U，其它顶点作为V。这时，只含有1个顶点的U，其MST-U就是vertex本身，这是已知的。（已经符合假设了）而V范围内的连接方式尚属未知。根据刚刚的推理，我们已经可以求得连接MST-U和MST-V的那条边u-v，顺着u-v，就可以把V中的顶点v拉到U里边。这样重复地拉取顶点，直到V中没有顶点时，U就覆盖了整个G，我们就求得了整个G的MST！

    public partial class AdjacencyListGraph<TVertex, TEdge>
    {
        AdjacencyListGraph<TVertex, TEdge> Prim()
        {
            if (this.Vertexes.Count == 0) { return null; }

            var result = new AdjacencyListGraph<TVertex, TEdge>();
            var firstVertex = this.Vertexes[0].ShallowCopy();// get a copy of this.Vertex[0] without its edges' information.
            result.Vertexes.Add(firstVertex);// initialize U collection.
            var VCollection = new List<AdjacencyListVertex<TVertex, TEdge>>(from item in this.Vertexes where item != this.Vertexes[0] select item);// initialize V collection.
            var this2ResultVertex = new Dictionary<AdjacencyListVertex<TVertex, TEdge>, AdjacencyListVertex<TVertex, TEdge>>();
            var result2ThisVertex = new Dictionary<AdjacencyListVertex<TVertex, TEdge>, AdjacencyListVertex<TVertex, TEdge>>();
            this2ResultVertex.Add(this.Vertexes[0], firstVertex);
            result2ThisVertex.Add(firstVertex, this.Vertexes[0]);
            while (VCollection.Count > 0)
            {
                AdjacencyListVertex<TVertex, TEdge> u = null;
                AdjacencyListEdge<TVertex, TEdge> e = null;
                AdjacencyListVertex<TVertex, TEdge> v = null;
                foreach (var item in result.Vertexes)
                {
                    var tmpU = result2ThisVertex[item];// get back to 'this' vertex of U
                    foreach (var tmpE in tmpU.Edges)
                    {
                        var tmpV = tmpE.GetTheOtherVertex(tmpU);
                        if (tmpV != null)
                        {
                            if (VCollection.Contains(tmpV))// if (tmpV is in V collection)
                            {
                                if ((e == null) || (tmpE.Weight < e.Weight))
                                {
                                    u = tmpU; e = tmpE; v = tmpV;
                                }
                            }
                        }
                        else
                        {
                            throw new Exception("Graph has invalid edge!");
                        }
                    }
                }

                if (e != null)
                {
                    var nextVertex = v.ShallowCopy();
                    result2ThisVertex.Add(nextVertex, v);
                    this2ResultVertex.Add(v, nextVertex);
                    var vertex = this2ResultVertex[u];
                    var edge = new AdjacencyListEdge<TVertex, TEdge>(vertex, nextVertex, e.Weight);
                    vertex.Edges.Add(edge); nextVertex.Edges.Add(edge);
                    result.Vertexes.Add(nextVertex);// add new vertex to U collection.
                    VCollection.Remove(v);// remove v from V collection.
                }
                else// the graph is not connected!
                {
                    result = null;
                    break;
                }
            }

            return result;
        }
    }
    public partial class AdjacencyListEdge<TVertex, TEdge>
    {
        public AdjacencyListVertex<TVertex, TEdge> Vertex1 { get;set; }
        public AdjacencyListVertex<TVertex, TEdge> Vertex2 { get;set; }
        public virtual int Weight { get;set; }

        public AdjacencyListVertex<TVertex, TEdge> GetTheOtherVertex(AdjacencyListVertex<TVertex, TEdge> vertex)
        {
            if (vertex == null) { return null; }
            
            if (this.Vertex1 == vertex) { return this.Vertex2; }
            else if (this.Vertex2 == vertex) { return this.Vertex1; }
            else
            { throw new ArgumentException("edge is not banded to vertex!"); }
        }
    }

Kruskal算法

关于Kruskal（以及任何算法），网上给的反证法、数学归纳法都不适合学习和锻炼算法能力，那些都是在感性认知和灵感走通了迷途之后才适合进行的形而上的东西。

还是按这样的思路来想吧：假设我们已经得到了有N个顶点的图G1的MST-G1，其中G1至少有1个顶点。（又是这种神奇的假设）现在给G1增加一个新顶点v，并用若干条边将v和G1中的某些顶点连接起来。这样我们得到了一个新图G2。与v相连的边中，我们取权值最小的那个（记作v-w），那么MST-G1和v-w加起来就是G2的一个生成树ST。

如果v-w不取最小的那个，那么得到的ST的权值就会增大。如果ST中的MST-G1部分有所改变，那么ST的权值也会增大（或不变）。也就是说，无论我们如何修改ST中的边，ST的权值都不会减小（只会增大或保持不变）。所以ST其实就是G2的最小生成树MST-G2。

由于对G1的约束条件只有"至少有1个顶点"这么一丢丢的限制，那么G2其实可以是任何顶点数V>1的图。

也就是说对于任何顶点数V>1的图G，都可以使用如下方法得到其MST：

• 设置数组M，用于保存构成MST的边。
• 在所有未加入M的边中，选取最小的一条边E，如果E满足"E与所有已加入M的边都不构成回路"，就把E加入M。
• 重复执行上一步，直到标记了V-1条边为止。

注：对于顶点数V=1的图，上述方法也适用。

上述三步就是Kruskal算法。它利用了上文的推理：如果得到了N个顶点的图的MST，就能够得到N+1个顶点的图的MST。这就意味着，我们可以从只有1个顶点的图开始，得到任意有限个顶点的图的MST。它的做法是"每次都尽可能取权值小的边"。这是算法理论中的贪心思想。

注：为了方便进行"选取最小的一条边"这个重复性操作，首先需要对边进行升序排序。

    public partial class AdjacencyListGraph<TVertex, TEdge>
    {
        AdjacencyListGraph<TVertex, TEdge> Kruskal()
        {
            if (this.Vertexes.Count == 0) { return null; }

            var edgeSorter = new EdgeSorter<TVertex, TEdge>();
            var report = this.Traverse(edgeSorter, GraphTraverseOrder.DepthFirst, true);// sort edges.
            if (report.ConnectedComponents.Count > 1) { return null; }

            var count = this.Vertexes.Count - 1;
            var selectedEdges = new List<AdjacencyListEdge<TVertex, TEdge>>();
            var components = new List<List<AdjacencyListVertex<TVertex, TEdge>>>();
            foreach (var edge in edgeSorter.sortedEdges)// get selected edges for MST.
            {
                if (selectedEdges.Count >= count) { break; }
                TryAddEdge(edge, selectedEdges, components);
            }
            
            var result = GetMST(selectedEdges);
            return result;
        }
        
        AdjacencyListGraph<TVertex, TEdge> GetMST(List<AdjacencyListEdge<TVertex, TEdge>> selectedEdges)
        {
            var result = new AdjacencyListGraph<TVertex, TEdge>();
            var this2ResultDict = new Dictionary<AdjacencyListVertex<TVertex, TEdge>, AdjacencyListVertex<TVertex, TEdge>>();
            foreach (var vertex in this.Vertexes)// get vertexes for MST.
            {
                var newVertex = vertex.ShallowCopy();
                this2ResultDict.Add(vertex, newVertex);
                result.Vertexes.Add(newVertex);
            }

            foreach (var selected in selectedEdges)// get edges for MST.
            {
                var v1 = this2ResultDict[selected.Vertex1];
                var v2 = this2ResultDict[selected.Vertex2];
                var newEdge = new AdjacencyListEdge<TVertex, TEdge>(v1, v2, selected.Weight);
                v1.Edges.Add(newEdge);
                v2.Edges.Add(newEdge);
            }
            return result;
        }
        
        bool TryAddEdge(AdjacencyListEdge<TVertex, TEdge> edge, List<AdjacencyListEdge<TVertex, TEdge>> selectedEdges, List<List<AdjacencyListVertex<TVertex, TEdge>>> components)
        {
            List<AdjacencyListVertex<TVertex, TEdge>> component1 = null;
            List<AdjacencyListVertex<TVertex, TEdge>> component2 = null;
            foreach (var component in components)
            {
                foreach (var v in component)
                {
                    if (v == edge.Vertex1)
                    { component1 = component; }
                    if (v == edge.Vertex2)
                    { component2 = component; }
                }
            }
            if (component1 != null)
            {
                if (component2 != null)
                {
                    if (component1 == component2)
                    { return false; }
                    else
                    {
                        component1.AddRange(component2);
                        components.Remove(component2);
                        selectedEdges.Add(edge);
                        return true;
                    }
                }
                else
                {
                    component1.Add(edge.Vertex2);
                    selectedEdges.Add(edge);
                    return true;
                }
            }
            else
            {
                if (component2 != null)
                {
                    component2.Add(edge.Vertex1);
                    selectedEdges.Add(edge);
                    return true;
                }
                else
                {
                    var component = new List<AdjacencyListVertex<TVertex, TEdge>>();
                    component.Add(edge.Vertex1);
                    component.Add(edge.Vertex2);
                    components.Add(component);
                    selectedEdges.Add(edge);
                    return true;
                }
            }
        }
    }

对边排序我使用了折半插入排序。

    public class EdgeSorter<TVertex, TEdge> : GraphNodeWorker<TVertex, TEdge>
    {
        public IList<AdjacencyListEdge<TVertex, TEdge>> sortedEdges = new List<AdjacencyListEdge<TVertex, TEdge>>();
        int count = 0;
        public override void DoActionOnNode(AdjacencyListVertex<TVertex, TEdge> vertex)
        {
            if (vertex == null) { return; }
            foreach (var edge in vertex.Edges)
            {
                if (!sortedEdges.Contains(edge))
                {
                    InsertElement(edge);
                }
            }
        }
        // optimized verstion of InsertElement() method.
        void InsertElement(AdjacencyListEdge<TVertex, TEdge> element)
        {
            var min = 0;
            var max = count - 1;
            while (min <= max)
            {
                var middle = (min + max) / 2;
                if (element.Weight - this.sortedEdges[middle].Weight < 0)
                { max = middle - 1; }
                else
                { min = middle + 1; }
            }

            this.sortedEdges.Insert(min, element);
            count++;
        }

        /* this is the original version which is not optimized.
        void InsertElement(AdjacencyListEdge<TVertex, TEdge> element)
        {
            if (count == 0) { this.sortedEdges.Add(element); return; }
            var min = 0;
            var max = count - 1;
            var middle = 0;
            var compare = 0;
            while (min <= max)
            {
                middle = (min + max) / 2;
                compare = element.Weight - sortedEdges[middle].Weight;
                if (compare < 0)
                { max = middle - 1; }
                else
                { min = middle + 1; }
            }
            if (compare < 0)
            {
                this.sortedEdges.Insert(middle, element);//(min) equals (middle) equals (max + 1)
            }
            else
            {
                this.sortedEdges.Insert(middle + 1, element);//(min) equals (middle + 1) equals (max + 1)
            }
            count++;
        }
        */
    }

对比测试

实现了Prim和Kruskal算法后，就该测试一下他们的正确性了。思考了2天后，我认为如下方案既简单可行又有足够的说服力：仍旧用上一篇的方法自动生成顶点数为1、2、3、4、5、6的所有图的形态，并对其边随机赋予权值；然后对得到的每一个图G，分别用Prim和Kruskal算法计算MST；然后对比两种算法得到的MST的总权值是否相同；如果不同，就说明至少有一个算法的代码有问题；如果对所有情形的图的计算，其Prim和Kruskal得到的MST权值都分别相同，那就很强地说明代码没问题。由于各个边的权值是随机给的，可以通过多次重复测试的方式，进一步加强说明代码的正确性。

这种逼近式的对比测试，其实现很容易且说服力很强；同时，真正的完全测试我实在精力不足，这决定了我采用如上所述的测试策略。

测试思路已经给出了，代码也简单地很，下面只给出一个测试用例作为示例。

这个测试用例说明了如下内容：

这是第1099个测试用例。

这个图只有1个连通分量（即这个图是一个连通图）

这个图有5个顶点（其ID分别为0、1、2、3、4）

这个图的各个边用折线表示如上图所示（右侧的数值为该边的权值）

排序后的边情况如下（格式为"顶点ID-权值-顶点ID"）

MST总权值为8。

（由于Prim和Kruskal计算结果相同，没有其他信息）

最后一行统计了出错的测试用例数量：0。

需要本文源代码的话麻烦点个赞并留下你的Email~