摘要：本文简要介绍了采用贪心策略的最小生成的生成算法——Prim算法。文中首先给出了一个易于理解

的O(N^3)的实现，然后给出了优化后的O（N^2)实现，也就是许多算法书上的Prim算法实现了。

关键字：最小生成树，Prim算法，贪心，普里姆

在无向带权连通图G中，如果一个连通子树包含所有顶点，并且连接这些顶点的边权之和最小，

那么这个连通子图就是G的最小生成树。求最小生成树的一个常见算法是Prim算法，该算法的基本思想

是：1）设置两个集合V和S，任意选择一个顶点作为起始顶点，将起始顶点放入集合S，其余顶点存入集合

V中；2）然后使用贪心策略，选择一条长度最短并且端点分别在S和V中边（即为最小生成树的中的一条

边），将这条边在V中的端点加入到集合S中；3）循环执行第2）步直到S中包含了所有顶点。

根据以上思想我们很快可以给出一个O（N^3)的算法，即选择一条最短边需要O（N^2)的时间复杂度，

具体实现代码如下：

// O(N^3)
#include 

using namespace std;

//用邻接矩阵表示无向图
#define N 6 //节点个数
#define M 100000//最大值，表示不可达
int matrix[N][N]=
{
    M,6,1,5,M,M,
    6,M,5,M,3,M,
    1,5,M,5,6,4,
    5,M,5,M,M,2,
    M,3,6,M,M,6,
    M,M,4,2,6,M
};

void prim()
{
    bool flag[N]; //标记某个点是否当前生成树集合中
    int i,j;
    //初始化集合
    for(i = 0; i < N; ++i) flag[i] = false;

    flag[0] = true;
    int count = 1;
    while(count++ < N)
    {
        int min = M;
        int e1 = -1, e2 = -1;
        for(i = 0; i < N; ++i)
        {
            if(flag[i])
            {
                for(j = 0; j < N; ++j)
                {
                    if(!flag[j])
                    {
                        if(matrix[i][j] < min)
                        {
                            min = matrix[i][j];
                            e1 = i;
                            e2 = j;
                        }
                    }
                }
            }
        }
        cout << e1 + 1 << "-" << e2 + 1<<" "<< matrix[e1][e2] << endl;
        flag[e2] = true;
    }
}

int main(int argc, char* *argv)
{
    prim();
    system("pause");
    return 0;
}

上面的算法有三个循环，时间复杂度为O（N^3)，考虑到由于使用的是贪心策略，则每添加一个新

顶点到集合S中的时候，才会改变V中每个点到S中点的最小边的长度。因此可以用一个数组nearest[N](N为

顶点个数）记录在生成最小数的过程中，记录V中每个点的到S中点的最小变长，用另外一个数组

adjecent[N]记录使得该边最小的对应的邻接点。那么O（N）的时间了找到最短的边，并且能在O（N)的

时间里更新nearest[N]和adjecent[N]。因此可以得到O(N^2)的算法。源码实现如下：

//O(N^2)
#include 

using namespace std;

//用邻接矩阵表示无向图
#define N 6 //节点个数
#define M 100000//最大值，表示不可达
int matrix[N][N]=
{
    M,6,1,5,M,M,
    6,M,5,M,3,M,
    1,5,M,5,6,4,
    5,M,5,M,M,2,
    M,3,6,M,M,6,
    M,M,4,2,6,M
};

void prim()
{
    //记当前生成树的节点集合为S
    //未使用的节点结合为V
    bool flag[N]; //标记某个点是否在S中
    int nearest[N]; //记录V中每个点到S中邻接点的最短边
    int adjecent[N];//记录与V中每个点最邻接近的点
    int i,j,min;
    //初始化集合
    for(i = 0; i < N; ++i) flag[i] = false;

    flag[0] = true;
    for(i = 1; i < N; ++i)
    {
        nearest[i] = matrix[0][i];
        adjecent[i] = 0;
    }
    int count = N;
    while(--count)
    {
        min = M;
        j = 0;
        for(i = 0; i < N; ++i)
        {
            if(!flag[i] && nearest[i] < min)
            {
                min = nearest[i];
                j = i;
            }
        }

        cout << j + 1 << "-" << adjecent[j] + 1 << " " << matrix[j][adjecent[j]] << endl;
        flag[j] = true;

        for(i = 0; i < N; ++i)
        {
            if(!flag[i] && matrix[i][j] < nearest[i])
            {
                nearest[i] = matrix[i][j];
                adjecent[i] = j;
            }
        }
    }
}

int main(int argc, char* *argv)
{
    prim();
    system("pause");
    return 0;
}

注：文中代码在VC++ 6.0编译器中测试通过。

参考资料：计算机算法分析与设计(第三版)