最小生成树-Prim算法与Kruskal算法

一、最小生成树(MST)

　　①、生成树的代价：设G=（V，E）是一个无向连通网，生成树上各边的权值之和称为该生成树的代价。

　　②、最小生成树：在图G所有生成树中，代价最小的生成树称为最小生成树。

　　最小生成树的概念可以应用到许多实际问题中。 例：在n个城市之间建造通信网络，至少要架设n-1条通信线路，而每两个城市之间架设通信线路的造价是不一样的，那么如何设计才能使得总造价最小？

　　③、MST性质：假设G=(V, E)是一个无向连通网，U是顶点集V的一个非空子集。若(u, v)是一条具有最小权值的边，其中u∈U，v∈V－U，则必存在一棵包含边(u, v)的最小生成树。

二、Prim算法

　　①基本思想：设G=(V, E)是具有n个顶点的连通网，T=(U, TE)是G的最小生成树， T的初始状态为U={u0}（u0∈V），TE={ }，重复执行下述操作：在所有u∈U，v∈V-U的边中找一条代价最小的边(u, v)并入集合TE，同时v并入U，直至U=V。

　　关键:是如何找到连接U和V-U的最短边，利用MST性质，可以用下述方法构造候选最短边集：对应V-U中的每个顶点，保留从该顶点到U中的各顶点的最短边。

　　②数据结构设计

　　数组lowcost[n]：用来保存集合V-U中各顶点与集合U中顶点最短边的权值，lowcost[v]=0表示顶点v已加入最小生成树中；

　　数组adjvex[n]：用来保存依附于该边（集合V-U中各顶点与集合U中顶点的最短边）在集合U中的顶点。

　　如何用数组lowcost和adjvex表示候选最短边集？

　　lowcost[i]=w；表示顶点vi和顶点vk之间的权值为w，

　　adjvex[i]=k；其中：vi∈ V-U 且vk ∈U。

　　③Prim算法——伪代码

. 初始化两个辅助数组lowcost和adjvex；
. 输出顶点u0，将顶点u0加入集合U中；
. 重复执行下列操作n-1次
   3.1 在lowcost中选取最短边，取adjvex中对应的顶点序号k；
   3.2 输出顶点k和对应的权值；
   3.3 将顶点k加入集合U中；
   3.4 调整数组lowcost和adjvex；

　　④C++实现

 #include<iostream>
 #include<fstream>
 using  namespace std;

 #define MAX 100
 #define MAXCOST 0x7fffffff

 int graph[MAX][MAX];

 /*方法二*/
 struct Node
 {
     int lowcost;// 权值
     int adjvex;// 候选最短边的邻接点
 };
 Node shortEdge[MAX];// 候选最短边集合
 void prim2(int graph[][MAX], int n)
 {
      // 初始化辅助数组shortEdge,所有点到点1的权值
     for (int i = ; i <= n; i++)
     {
         shortEdge[i].lowcost = graph[][i];
         shortEdge[i].adjvex = ;
     }
     shortEdge[].lowcost = ;// 将顶点1加入集合U
     for (int i = ; i <= n; i++)
     {
         // 寻找最短边的邻接点k
         int k = , min = MAXCOST;
         for (int j = ; j <= n; j++)
         {
             if (min >shortEdge[j].lowcost&&shortEdge[j].lowcost!=)
             {
                 min = shortEdge[j].lowcost;
                 k = j;
             }
         }
         cout << "(" << k << shortEdge[k].adjvex << ")" << shortEdge[k].lowcost;
         shortEdge[k].lowcost = ;// 将顶点k加入结合U中
         for (int j = ; j <= n; j++)
         {
             if (graph[k][j] < shortEdge[j].lowcost)
             {
                 shortEdge[j].lowcost = graph[k][j];
                 shortEdge[j].adjvex = k;
             }
         }
     }
 }

 int main()
 {
     int i, j, k, m, n;
     int x, y, cost;
     ifstream in("input.txt");
     in >> m >> n;//m=顶点的个数，n=边的个数
     //初始化图G
     for (i = ; i <= m; i++)
     {
         for (j = ; j <= m; j++)
         {
             graph[i][j] = MAXCOST;
         }
     }
     //构建图G
     for (k = ; k <= n; k++)
     {
         in >> i >> j >> cost;
         graph[i][j] = cost;
         graph[j][i] = cost;
     }
     prim2(graph, m);
     system("pause");
     return ;
 }

三、Kruskal算法

　　①基本思想：设无向连通网为G＝(V, E)，令G的最小生成树为T＝(U, TE)，其初态为U＝V，TE＝{ }，然后，按照边的权值由小到大的顺序，考察G的边集E中的各条边。若被考察的边的两个顶点属于T的两个不同的连通分量，则将此边作为最小生成树的边加入到T中，同时把两个连通分量连接为一个连通分量；若被考察边的两个顶点属于同一个连通分量，则舍去此边，以免造成回路，如此下去，当T中的连通分量个数为1时，此连通分量便为G的一棵最小生成树。

　　②数据结构设计：因为Kruskal算法是依次对图中的边进行操作，因此考虑用边集数组存储图中的边，为了提高查找最短边的速度，可以先对边集数组按边上的权值排序。

 struct EdgeType
 {
     int from, to;// 边依附的两个顶点
     int weight;// 边的权值
 };

 template<class T>
 struct EdgeGraph
 {
     T vertex[Maxvertex];// 存放顶点信息
     vector<EdgeType> edge;// 存放边的数组(用vector便于排序)
     int vertexNum, edgeNum;//顶点数和边数
 };

　　③Kruskal算法——伪代码

. 初始化：U=V；  TE={ }；
. 循环直到T中的连通分量个数为1
     2.1 在E中寻找最短边(u，v);
     2.2 如果顶点u、v位于T的两个不同连通分量，则
           2.2. 将边(u，v)并入TE；
           2.2. 将这两个连通分量合为一个；
     2.3 在E中标记边(u，v)，使得(u，v)不参加后续最短边的选取；

　　④C++实现

#include<iostream>
#include<fstream>
#include<vector>
#include<algorithm>
using  namespace std;

const int Maxvertex = ;// 最多顶点数
const int MaxEdge = ;// 最多边数

struct EdgeType
{
    int from, to;// 边依附的两个顶点
    int weight;// 边的权值
};

template<class T>
struct EdgeGraph
{
    T vertex[Maxvertex];// 存放顶点信息
    vector<EdgeType> edge;// 存放边的数组(用vector便于排序)
    int vertexNum, edgeNum;//顶点数和边数
};
int FindRoot(int parent[], int v)// 求顶点的双亲结点
{
    int t = v;
    while(parent[t]> -)
        t = parent[t];
    return t;
}
void Kruskal(EdgeGraph<int> G)
{
    int parent[Maxvertex];
    for (int i = ; i < G.vertexNum; i++)
        parent[i] = -;// 表示顶点i没有双亲结点
    for (int num = , i = ; i < G.edgeNum; i++)
    {
        int vex1 = FindRoot(parent, G.edge[i].from);
        int vex2 = FindRoot(parent, G.edge[i].to);
        if (vex1 != vex2)
        {
            cout << "(" << G.edge[i].from << G.edge[i].to << ")" << endl;
            parent[vex2] = vex1;// 合并生成树
            num++;
            if (num == G.vertexNum - )
                return;
        }
    }

}

bool sort_by_weight(EdgeType&k1, EdgeType&k2)
{
    return k1.weight < k2.weight;
}
int main()
{
    EdgeGraph<int> Edgraph;// 存放图的信息
    ifstream in("input.txt");
    in >> Edgraph.vertexNum >> Edgraph.edgeNum;
    //构建图G
    for (int k = ; k <Edgraph.edgeNum; k++)
    {
        EdgeType temp;
        in >> temp.from >> temp.to >> temp.weight;
        Edgraph.edge.push_back(temp);
    }
    // 将边按照权值排序
    sort(Edgraph.edge.begin(), Edgraph.edge.end(), sort_by_weight);
    Kruskal(Edgraph);
    system("pause");
    return ;
}

input.txt