图论中的最小生成树：Kruskal与Prim算法深入解析

•                                           ***🎬慕斯主页***：*******修仙—别有洞天********
  
                                          ♈️*今日夜电波：*アンビバレント—Uru**
  
                                                            0:24━━━━━━️💟──────── 4:02
                                                                 🔄   ◀️   ⏸   ▶️    ☰  
  
                                  💗关注👍点赞🙌收藏*您的每一次鼓励都是对我莫大的支持*😍
  

最小生成树

    最小生成树（Minimum Spanning Tree，简称 MST）是**一个无向连通图中包含所有顶点的边的权值之和最小的子图**。它有以下特点：

1. 包含原图所有顶点：最小生成树是一个生成树，因此它必须包含图中的所有顶点。
2. 边的权值之和最小：在所有的生成树中，最小生成树是边的权值总和最小的那一个。
3. 是无环的：作为一棵树，最小生成树中不存在环，即任意两个顶点之间有且仅有一条路径相连。

    求解最小生成树的常用算法有两种：

• Kruskal算法：该算法的基本思想是按照边的权值从小到大的顺序选择边，如果这条边连接的两个顶点不在同一个连通分量中，则加入这条边，直到所有顶点都被包含在内。这个过程中，使用并查集数据结构来判断两个顶点是否属于同一个连通分量是非常有效的。
• Prim算法：与Kruskal算法不同，Prim算法是一种贪心算法，它从任意一个顶点开始，每一步都选择连接当前已选取顶点集合与未选取顶点集合之间权值最小的边，并将其加入到最小生成树中，直到所有顶点都被包含。

    总的来说，最小生成树的概念在许多领域都有应用，如网络设计、交通规划等，它可以帮助找到成本最低的连接方案。

Kruskal算法

如何理解Kruskal算法？

    Kruskal算法是一种用来寻找最小生成树的贪心算法，它的核心思想是**选择边权值之和最小的同时不会形成环路的边来构建最小生成树**。（使用的就是全局的贪心策略）具体步骤如下：

1. 边的排序：将图中的所有边按照权值从小到大进行排序。（这一步我们可以使用到优先级队列）
2. 初始化并查集：使用并查集数据结构来记录各个顶点的连通性，初始时每个顶点自成一个集合。
3. 遍历边并检查环路：按权值从小到大的顺序遍历每条边，利用并查集判断这条边连接的两个顶点是否属于不同的集合。如果是，则加入这条边并不会形成环路，因此将其加入到最小生成树中，并将这两个顶点所在的集合合并。
4. 重复直至完成：重复上述步骤，直到添加了V-1条边（V为图中顶点的数量），此时便形成了包含所有顶点的最小生成树。

  ***  需要注意的是***，在应用Kruskal算法时，需要确保图是连通的，因为**算法只能处理连通图的最小生成树问题**。如果图不是连通的，那么需要先对图进行连通分量的分析，然后对每个连通分量分别求解最小生成树。大致图解如下：

​

Kruskal算法的实现

    本文的Kruskal算法**是在邻接矩阵的基础上进行实现的**，邻接矩阵的实现***参考上一篇文章***，这里先实现边的结构体，给定两个size_t类型表示源地址_srcI以及目标地址_dstI（实际上就是对应顶点的下标），根据模版类型W来存储边的权值_w，并且重载了一个>符，用于后续优先级队列中对于伪函数的使用，实现如下：

        struct Edge
        {
            size_t _srci;
            size_t _dsti;
            W _w;

            Edge(size_t srci, size_t dsti, const W& w)
                :_srci(srci)
                , _dsti(dsti)
                , _w(w)
            {}

            bool operator>(const Edge& e) const
            {
                return _w > e._w;
            }

        };

***   ** 需要注意：***前面我们将整个邻接矩阵都已经重新命名了，这样做是为了更好的定义最小生成树，毕竟他本质上也是一个图，并且也是在原来的基础上定义的，我们当然可以使用原来的数据结构：

typedef Graph<V, W, MAX_W, Direction> Self;

    接下来，按照上述的实现步骤一步一步实现：（1）初始化，由于最小生成树对于原图可能只是变小于等于原图，其他实际上都是一样的。因此，我们可以根据原图进行初始化，**顶点的存储、顶点同下标的映射都是一样的，只是边需要重新构建！**其中MAX_W是作为初始化边的值，**默认为INT_MAX**。（2）使用优先级队列，**以升序的方式对上面我们构建的边结构体进行排序**，将原图的所有边都放入优先级队列！（3）选出n-1条边，首先定义一个变量**size用于储存有多少条边被选**，定义一个**totalW用于储存权值**，定义一个**并查集ufs用于查环**。每次遍历都会将优先级队列的顶部值取出，***上一篇文章中提到过InSet是用于判断是否为同一根节点（判环）的操作***，若不为环则按照邻接矩阵的方法构造边，并且也在并查集中合并在一起。（4）这个循环中不论如何都会**将优先级队列中的值全部释放，然后退出循环，最后根据size来判断是否可以形成最小生成树并且返回权值**。如下为具体的实现：

        W Kruskal(Self& minTree)
        {
            size_t n = _vertexs.size();

            minTree._vertexs = _vertexs;
            minTree._indexMap = _indexMap;
            minTree._matrix.resize(n);
            for (size_t i = 0; i < n; ++i)
            {
                minTree._matrix[i].resize(n, MAX_W);
            }

            priority_queue<Edge, vector<Edge>, greater<Edge>> minque;
            for (size_t i = 0; i < n; ++i)
            {
                for (size_t j = 0; j < n; ++j)
                {
                    if (i < j && _matrix[i][j] != MAX_W)
                    {
                        minque.push(Edge(i, j, _matrix[i][j]));
                    }
                }
            }

            // 选出n-1条边
            int size = 0;
            W totalW = W();
            UnionFindSet ufs(n);
            while (!minque.empty())
            {
                Edge min = minque.top();
                minque.pop();

                if (!ufs.InSet(min._srci, min._dsti))
                {
                    cout << _vertexs[min._srci] << "->" << _vertexs[min._dsti] << ":" << min._w << endl;
                    minTree._AddEdge(min._srci, min._dsti, min._w);
                    ufs.Union(min._srci, min._dsti);
                    ++size;
                    totalW += min._w;
                }
                else
                {
                    cout << "构成环：";
                    cout << _vertexs[min._srci] << "->" << _vertexs[min._dsti] << ":" << min._w << endl;
                }
            }

            if (size == n - 1)
            {
                return totalW;
            }
            else
            {
                return W();
            }
        }

Prim算法

如何理解Prim算法？

    Prim算法是一种用于求解加权连通无向图中最小生成树的算法。它的核心思想是**从一个顶点开始，逐步扩展已选取的顶点集合，直到所有顶点都被包含在内**。（使用的就是局部的贪心策略）具体步骤如下：

1. 选择起始点：从图中任意选择一个顶点作为起始点。
2. 构建边界集：将起始点加入已选取的顶点集合中，同时维护一个边界顶点集合，这些顶点是已选取顶点集合与未选取顶点集合之间的边界。
3. 选择轻量级边：在边界集合中选择权值最小的边，将该边以及其连接的未选取顶点加入到已选取集合中。
4. 更新边界集：更新边界集合，将新加入的顶点作为新的边界顶点。
5. 重复直至完成：重复步骤3和步骤4，直到所有顶点都被加入到已选取的顶点集合中，此时形成的树即为最小生成树。

    总的来说，Prim算法的关键在于每一步都选择当前最优的选择，即权值最小的边，以此来保证最终得到的是最小生成树。这种贪心策略确保了算法的效率和结果的最优性。大致图解如下：

​

Prim算法的实现

    由于Prim是由局部逐步扩散到全局的，也就是说***他并不会选择到选过的顶点***，因此Prim的实现并不需要使用到并查集。对于上面Kruskal提到的Edge以及Self不多阐述。

    由于Prim需要指定一个顶点开始，因此接口相对Kruskal多传了一个顶点。接下来，按照上述的实现步骤一步一步实现：（1）初始化，同Kruskal一样，我们都是**使用邻接矩阵来实现的**，因此前期初始化是相同的操作，接着，获取对应的顶点下标映射，创建**两个bool数组分别用于表示已选取的顶点集合和未选取顶点集合，true表示拥有该顶点，false表示不拥有**。最后按照下标映射初始化两个数组，**选取的则改为true，未选改为false**，完成初始化。（2）使用优先级队列先将开始顶点的边放入队列中，同样设置size和totalW。（3）开始选边，出队列顶的边，通过**判断是否在已选取的顶点集合来判断是否可选**（可以变相理解为是否成环），如果不在表示为没有选过因此可以选，选取后将已选取的顶点集合和未选取顶点集合分别改变，再**根据刚刚选取的点选取他临界的顶点**。（4）在这个循环中，可能会出现很多重复的点的情况，但是我们有已选取的顶点集合来判断是否可选，这样不可选的会自动出队列而不被选取，**最后根据size来判断是否可以形成最小生成树并且返回权值**。

    具体实现如下：

        W Prim(Self& minTree, const W& src)
        {
            size_t srci = GetVertexIndex(src);
            size_t n = _vertexs.size();

            minTree._vertexs = _vertexs;
            minTree._indexMap = _indexMap;
            minTree._matrix.resize(n);
            for (size_t i = 0; i < n; ++i)
            {
                minTree._matrix[i].resize(n, MAX_W);
            }

            /*set<int> X;
            set<int> Y;
            X.insert(srci);
            for (size_t i = 0; i < n; ++i)
            {
                if (i != srci)
                {
                    Y.insert(i);
                }
            }*/

            vector<bool> X(n, false);
            vector<bool> Y(n, true);
            X[srci] = true;
            Y[srci] = false;

            // 从X->Y集合中连接的边里面选出最小的边
            priority_queue<Edge, vector<Edge>, greater<Edge>> minq;
            // 先把srci连接的边添加到队列中
            for (size_t i = 0; i < n; ++i)
            {
                if (_matrix[srci][i] != MAX_W)
                {
                    minq.push(Edge(srci, i, _matrix[srci][i]));
                }
            }

            cout << "Prim开始选边" << endl;
            size_t size = 0;
            W totalW = W();
            while (!minq.empty())
            {
                Edge min = minq.top();
                minq.pop();

                // 最小边的目标点也在X集合，则构成环
                if (X[min._dsti])
                {
                    //cout << "构成环:";
                    //cout << _vertexs[min._srci] << "->" << _vertexs[min._dsti] << ":" << min._w << endl;
                }
                else
                {
                    minTree._AddEdge(min._srci, min._dsti, min._w);
                    //cout << _vertexs[min._srci] << "->" << _vertexs[min._dsti] << ":" << min._w << endl;
                    X[min._dsti] = true;
                    Y[min._dsti] = false;
                    ++size;
                    totalW += min._w;
                    if (size == n - 1)
                        break;

                    for (size_t i = 0; i < n; ++i)
                    {
                        if (_matrix[min._dsti][i] != MAX_W && Y[i])
                        {
                            minq.push(Edge(min._dsti, i, _matrix[min._dsti][i]));
                        }
                    }
                }
            }

            if (size == n - 1)
            {
                return totalW;
            }
            else
            {
                return W();
            }
        }

    **                感谢你耐心的看到这里ღ( ´･ᴗ･` )比心，如有哪里有错误请踢一脚作者o(╥﹏╥)o！** 

                                   ![](https://img-blog.csdnimg.cn/a2296f4aa7fd45e9b1a1c44f9b8432a6.gif)

** 给个三连再走嘛~ **