当前位置: 首页>>算法&结构>>正文


最小生成树算法(一)之Prim算法(C++实现)

qingchuan 算法&结构, 算法的力量 , , 去评论

摘要:本文简要介绍了采用贪心策略的最小生成的生成算法——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编译器中测试通过。

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

本文由《纯净的天空》出品。文章地址: https://vimsky.com/article/92.html,未经允许,请勿转载。