最小生成树MST（Minimum Spanning Tree)-普里姆(Prim)算法

简单讲解

图的定义时 我们规定一个连通图的生成树是一个极小连通子图 含有N个顶点N-1个边   我们把图中带权的边  最小代价生成的树成为最小生成树。   

普里姆(Prim)算法  prim算法适合稠密图，其时间复杂度为O(n^2)，其时间复杂度与边得数目无关以顶点找顶点 考虑权值 

            存储方式为邻接矩阵

基本思想：假设G＝(V，E)是连通的，TE是G上最小生成树中边的集合。算法从U＝{u0}（u0∈V）、TE＝{}开始。重复执行下列操作：

   在所有u∈U，v∈V－U的边(u，v)∈E中找一条权值最小的边(u0,v0)并入集合TE中，同时v0并入U，直到V＝U为止。

   此时，TE中必有n-1条边，T=(V，TE)为G的最小生成树。

   Prim算法的核心:始终保持TE中的边集构成一棵生成树。

注意：prim算法适合稠密图，其时间复杂度为O(n^2)，其时间复杂度与边得数目无关，

为了更好理解我们在这里举一个例子，示例如下：

 

（1）图中有6个顶点v1-v6，每条边的边权值都在图上；在进行prim算法时，我先随意选择一个顶点作为起始点，当然我们一般选择v1作为起始点，好，现在我们设U集合为当前所找到最小生成树里面的顶点，TE集合为所找到的边，现在状态如下：

U={v1}； TE={}；

（2）现在查找一个顶点在U集合中，另一个顶点在V-U集合中的最小权值，如下图，在红线相交的线上找最小值。

通过图中我们可以看到边v1-v3的权值最小为1，那么将v3加入到U集合，（v1，v3）加入到TE，状态如下：

U={v1，v3}； TE={（v1，v3）}；

（3）继续寻找，现在状态为U={v1，v3}； TE={（v1，v3）}；在与红线相交的边上查找最小值。

我们可以找到最小的权值为（v3，v6）=4，那么我们将v6加入到U集合，并将最小边加入到TE集合，那么加入后状态如下：

U={v1，v3，v6}； TE={（v1，v3），（v3，v6）}； 如此循环一下直到找到所有顶点为止。

（4）下图像我们展示了全部的查找过程：

#include<iostream>
#include<fstream>
using  namespace std;
#define MAX 100
#define MAXCOST 65535
int graph[MAX][MAX];
int Prim(int graph[][MAX], int m)//m 是点数
{
    int lowcost[m];
    int mst[m];
    int i, j, min, k, sum = 0;
    mst[1] = 0;
    lowcost[1]=0;
    for (i = 2; i <= m; i++)
    {
        lowcost[i] = graph[1][i];
        mst[i] = 1;
    }
    for (i = 2; i <= m; i++)
    {
        min = MAXCOST;
        k = 0;
        for (j = 2; j <= m; j++)
        {
            if (lowcost[j] < min && lowcost[j] != 0)
            {
                min = lowcost[j];
                k = j;//找到最小值下标
            }
        }
        cout << "V" << mst[k] << "-V" << k << "=" << min << endl;
        sum += min;
        lowcost[k] = 0;//到达k的距离为0 说明这个顶点完成了任务
        for (j = 2; j <= m; j++) // 更新lowcost 数组
        {
            if (lowcost[j] != 0 && graph[k][j] < lowcost[j])
            {
                lowcost[j] = graph[k][j];/本来到达不了 由于k的引入 可以到达了
                mst[j] = k; //这是不能总是从V1开始去别的点 把 现在能找到的近距离类似  mst[k]
            }
        }
    }
    return sum;
}
int main()
{
    int i, j, k, m, n;
    int cost;
    cout<<"please input V and E:";
    cin >> m >> n;//m=顶点的个数，n=边的个数
    //初始化图G
    for (i = 1; i <= m; i++)
    {
        for (j = 1; j <= m; j++)
        {
            graph[i][j] = MAXCOST;
        }
    }
    //构建图G
    cout<<"please intput i j and cost:"<<endl;
    for (k = 1; k <= n; k++)
    {
        cin >> i >> j >> cost;
        graph[i][j] = cost;
        graph[j][i] = cost;
    }
    //求解最小生成树
    cost = Prim(graph, m);
    //输出最小权值和
    cout << "最小权值和=" << cost << endl;
    return 0;
}

测试数据 V E

6 10

1 2 6 

1 3 1 

1 4 5 

2 3 5 

2 5 3 

3 4 5 

3 5 6 

3 6 4 

4 6 2 

5 6 6

结果

V1-V3=1 

V3-V6=4 

V6-V4=2 

V3-V2=5 

V2-V5=3 

最小权值和=15 

请按任意键继续. . .