最小连通网

如何在图中选择n-1条边使得n个顶点间两两可达，且这n-1条边的权值之和最小？

目标

必须使用且仅使用该网络中的n-1条边来联结网络中的n个顶点。
不能使用产生回路的边。
各边上的权值的总和达到最小。

Prim算法

代码实现：

//Prim算法 代码实现
#include <stdio.h>
#include <stdlib.h>

#define VNUM 9
#define MV 65536

int Path[VNUM];
int Cost[VNUM];
int Mark[VNUM];
int Matrix[VNUM][VNUM] =
{
    {0, 10, MV, MV, MV, 11, MV, MV, MV},
    {10, 0, 18, MV, MV, MV, 16, MV, 12},
    {MV, 18, 0, 22, MV, MV, MV, MV, 8},
    {MV, MV, 22, 0, 20, MV, MV, 16, 21},
    {MV, MV, MV, 20, 0, 26, MV, 7, MV},
    {11, MV, MV, MV, 26, 0, 17, MV, MV},
    {MV, 16, MV, MV, MV, 17, 0, 19, MV},
    {MV, MV, MV, 16, 7, MV, 19, 0, MV},
    {MV, 12, 8, 21, MV, MV, MV, MV, 0},
};

void Prim(int sv) // O(n*n)
{
    int i = 0;
    int j = 0;

    if( (0 <= sv) && (sv < VNUM) )
    {
        for(i=0; i<VNUM; i++)
        {
            Cost[i] = Matrix[sv][i];//表示已建立的连通图与未连接的图顶点（下标i）之间的权重 
            Path[i] = sv;//此处用Path数组表示边，代码表示由顶点sv到顶点i的边 
            Mark[i] = 0;//表示顶点是否使用 
        }

        Mark[sv] = 1;

        for(i=0; i<VNUM; i++)
        {
            int min = MV;
            int index = -1;

            for(j=0; j<VNUM; j++)
            {
                if( !Mark[j] && (Cost[j] < min) )//寻找权重最小的 
                {
                    min = Cost[j];
                    index = j;
                }
            }

            if( index > -1 )
            {
                Mark[index] = 1;                
                printf("(%d, %d, %d)\n", Path[index], index, Cost[index]);
            }    

            for(j=0; j<VNUM; j++)
            //把新找到的顶点发出的边的权重与其他连接到未连通的顶点的边权重比较 
            {
                if( !Mark[j] && (Matrix[index][j] < Cost[j]) )
                {
                    Cost[j]  = Matrix[index][j];//用最小的权重更新权重数组 
                    Path[j] = index;//找到最小的之后，加入新的顶点 
                }
            }
        }
    }
}

int main(int argc, char *argv[]) 
{
    Prim(0);

    return 0;
}

Kruskal算法

克鲁斯卡尔算法：通过边来得到最小连通网。

最终得到了边的集合T。

算法实现步骤：

1、定义边结构体

2、定义边集数组并排序

与上面小节的图结构相同：

3、定义辅助数组 P[n]
其中 n 为顶点数目，P[n]的用于记录边顶点的首尾连接关系。

4、算法核心思想

小结

Prim算法是针对顶点展开的，适合于边的数量较多的情况。
Kruskal算法是针对边展开的，适合于边的数量较少的情况。