最小生成树（Kruskal算法和Prim算法）

参考：https://blog.csdn.net/justinzengtm/article/details/82748556

转载：https://blog.csdn.net/a2392008643/article/details/81781766

在看题的时候，突然用到最小生成树的问题，结果忘记了，复习以下Kruskal和Prim算法

---

关于图的几个概念定义：

• 连通图：在无向图中，若任意两个顶点vivi与vjvj都有路径相通，则称该无向图为连通图。
• 强连通图：在有向图中，若任意两个顶点vivi与vjvj都有路径相通，则称该有向图为强连通图。
• 连通网：在连通图中，若图的边具有一定的意义，每一条边都对应着一个数，称为权；权代表着连接连个顶点的代价，称这种连通图叫做连通网。
• 生成树：一个连通图的生成树是指一个连通子图，它含有图中全部n个顶点，但只有足以构成一棵树的n-1条边。一颗有n个顶点的生成树有且仅有n-1条边，如果生成树中再添加一条边，则必定成环。
• 最小生成树：在连通网的所有生成树中，所有边的代价和最小的生成树，称为最小生成树。 

下面介绍两种求最小生成树算法

1.Kruskal算法

此算法可以称为“加边法”，初始最小生成树边数为0，每迭代一次就选择一条满足条件的最小代价边，加入到最小生成树的边集合里。 
1. 把图中的所有边按代价从小到大排序； 
2. 把图中的n个顶点看成独立的n棵树组成的森林； 
3. 按权值从小到大选择边，所选的边连接的两个顶点ui,viui,vi,应属于两颗不同的树，则成为最小生成树的一条边，并将这两颗树合并作为一颗树。 
4. 重复(3),直到所有顶点都在一颗树内或者有n-1条边为止。

2.Prim算法

此算法可以称为“加点法”，每次迭代选择代价最小的边对应的点，加入到最小生成树中。算法从某一个顶点s开始，逐渐长大覆盖整个连通网的所有顶点。

1. 图的所有顶点集合为VV；初始令集合u={s},v=V−uu={s},v=V−u;
2. 在两个集合u,vu,v能够组成的边中，选择一条代价最小的边(u0,v0)(u0,v0)，加入到最小生成树中，并把v0v0并入到集合u中。
3. 重复上述步骤，直到最小生成树有n-1条边或者n个顶点为止。

由于不断向集合u中加点，所以最小代价边必须同步更新；需要建立一个辅助数组closedge,用来维护集合v中每个顶点与集合u中最小代价边信息，：

struct
{
  char vertexData   //表示u中顶点信息
  UINT lowestcost   //最小代价
}closedge[vexCounts]

代码：

#include <iostream>
#include<vector>

using namespace std;

#define MAX_INT 999999
pair<int,int> GetShortestEdge(const vector<vector<int> >& Graph, const vector<bool>& isIncluded )//求当前在MST之外距离MST最近的点的id
{
    int minID = -1;
    int minDist = MAX_INT;
    pair<int,int> minEdge;
    for(int i = 0; i < Graph.size(); i++)//i为MST内的点
    {
        if(!isIncluded[i]) continue;//如果不在MST里面，则跳过
        for(int j = 0; j < Graph.size(); j++) //j为MST外的点
            if(!isIncluded[j] && Graph[i][j] < minDist){ //找到不在MST内但是距离MST最近的点
                minID = j;
                minDist = Graph[i][j];
                minEdge = make_pair(i,j);
            }
    }
    return minEdge;
}

vector<pair<int,int> > Prim(const vector<vector<int> >& Graph, vector<bool>& isIncluded){
    vector<pair<int,int> > MST;
    isIncluded[0] = true;
    //MST.push_back();
    for(int i = 1; i < Graph.size(); i++){
        pair<int,int> minEdge = GetShortestEdge(Graph, isIncluded); //找到这次要放入的边i，j
        MST.push_back(minEdge); //放入
        isIncluded[minEdge.second] = true; //将j标记为已经放入
    }
    return MST;
}

void addEdge( const int& startP, const int& endP, const int& weight ,vector<vector<int> >& Graph)
{
    Graph[startP][endP] = weight;
    Graph[endP][startP] = weight;
}

int main()
{
    int vertex_num = 6;
    vector<vector<int> > Graph(vertex_num, vector<int>(vertex_num, MAX_INT));
    addEdge(0,1,6 ,Graph);
    addEdge(0,2,1 ,Graph);
    addEdge(0,3,5 ,Graph);
    addEdge(1,2,5 ,Graph);
    addEdge(1,4,3 ,Graph);
    addEdge(2,3,5 ,Graph);
    addEdge(2,4,6 ,Graph);
    addEdge(2,5,4,Graph);
    addEdge(3,5,2,Graph);
    addEdge(4,5,6,Graph);
    vector<bool> isIncluded(vertex_num, false);
    vector<pair<int,int> >  MST = Prim(Graph, isIncluded);
    for(int i = 0; i < MST.size(); i++) //按照放入MST的顺序依次输出
        cout << MST[i].first+1 << "->" << MST[i].second+1 << endl;
    return 0;
}