Prim算法 求出 最小生成树

MST（Minimum Spanning Tree，最小生成树）问题有两种通用的解法，Prim算法就是其中之一，它是从点的方面考虑构建一颗MST，大致思想是：设图G顶点集合为U，首先任意选择图G中的一点作为起始点a，将该点加入集合V，再从集合U-V中找到另一点b使得点b到V中任意一点的权值最小，此时将b点也加入集合V；以此类推，现在的集合V={a，b}，再从集合U-V中找到另一点c使得点c到V中任意一点的权值最小，此时将c点加入集合V，直至所有顶点全部被加入V，此时就构建出了一颗MST。因为有N个顶点，所以该MST就有N-1条边，每一次向集合V中加入一个点，就意味着找到一条MST的边。

 

用图示和代码说明：

初始状态：

设置2个数据结构：

lowcost[i]:表示以i为终点的边的最小权值,当lowcost[i]=0说明以i为终点的边的最小权值=0,也就是表示i点加入了MST

mst[i]:表示对应lowcost[i]的起点，即说明边<mst[i],i>是MST的一条边，当mst[i]=0表示起点i加入MST

 

我们假设V1是起始点，进行初始化（*代表无限大，即无通路）：

 

lowcost[2]=6，lowcost[3]=1，lowcost[4]=5，lowcost[5]=*，lowcost[6]=*

mst[2]=1，mst[3]=1，mst[4]=1，mst[5]=1，mst[6]=1，（所有点默认起点是V1）

 

明显看出，以V3为终点的边的权值最小=1，所以边<mst[3],3>=1加入MST

此时，因为点V3的加入，需要更新lowcost数组和mst数组：

 

lowcost[2]=5，lowcost[3]=0，lowcost[4]=5，lowcost[5]=6，lowcost[6]=4

mst[2]=3，mst[3]=0，mst[4]=1，mst[5]=3，mst[6]=3

明显看出，以V6为终点的边的权值最小=4，所以边<mst[6],6>=4加入MST

 

此时，因为点V6的加入，需要更新lowcost数组和mst数组：

 

lowcost[2]=5，lowcost[3]=0，lowcost[4]=2，lowcost[5]=6，lowcost[6]=0

mst[2]=3，mst[3]=0，mst[4]=6，mst[5]=3，mst[6]=0

 

明显看出，以V4为终点的边的权值最小=2，所以边<mst[4],4>=4加入MST

 

此时，因为点V4的加入，需要更新lowcost数组和mst数组：

 

lowcost[2]=5，lowcost[3]=0，lowcost[4]=0，lowcost[5]=6，lowcost[6]=0

mst[2]=3，mst[3]=0，mst[4]=0，mst[5]=3，mst[6]=0

明显看出，以V2为终点的边的权值最小=5，所以边<mst[2],2>=5加入MST

 

此时，因为点V2的加入，需要更新lowcost数组和mst数组：

 

lowcost[2]=0，lowcost[3]=0，lowcost[4]=0，lowcost[5]=3，lowcost[6]=0

mst[2]=0，mst[3]=0，mst[4]=0，mst[5]=2，mst[6]=0

很明显，以V5为终点的边的权值最小=3，所以边<mst[5],5>=3加入MST

 

lowcost[2]=0，lowcost[3]=0，lowcost[4]=0，lowcost[5]=0，lowcost[6]=0

mst[2]=0，mst[3]=0，mst[4]=0，mst[5]=0，mst[6]=0

至此，MST构建成功，如图所示：

根据上面的过程，可以容易的写出具体实现代码如下（cpp）：

[cpp]  view plain  copy

 

 print?

1. #include<iostream>  
2. #include<fstream>  
3. using  namespace std;  
4.   
5. #define MAX 100  
6. #define MAXCOST 0x7fffffff  
7.   
8. int graph[MAX][MAX];  
9.   
10. int prim(int graph[][MAX], int n)  
11. {  
12.     int lowcost[MAX];  
13.     int mst[MAX];  
14.     int i, j, min, minid, sum = 0;  
15.     for (i = 2; i <= n; i++)  
16.     {  
17.         lowcost[i] = graph[1][i];  
18.         mst[i] = 1;  
19.     }  
20.     mst[1] = 0;  
21.     for (i = 2; i <= n; i++)  
22.     {  
23.         min = MAXCOST;  
24.         minid = 0;  
25.         for (j = 2; j <= n; j++)  
26.         {  
27.             if (lowcost[j] < min && lowcost[j] != 0)  
28.             {  
29.                 min = lowcost[j];  
30.                 minid = j;  
31.             }  
32.         }  
33.         cout << "V" << mst[minid] << "-V" << minid << "=" << min << endl;  
34.         sum += min;  
35.         lowcost[minid] = 0;  
36.         for (j = 2; j <= n; j++)  
37.         {  
38.             if (graph[minid][j] < lowcost[j])  
39.             {  
40.                 lowcost[j] = graph[minid][j];  
41.                 mst[j] = minid;  
42.             }  
43.         }  
44.     }  
45.     return sum;  
46. }  
47.   
48. int main()  
49. {  
50.     int i, j, k, m, n;  
51.     int x, y, cost;  
52.     ifstream in("input.txt");  
53.     in >> m >> n;//m=顶点的个数，n=边的个数  
54.     //初始化图G  
55.     for (i = 1; i <= m; i++)  
56.     {  
57.         for (j = 1; j <= m; j++)  
58.         {  
59.             graph[i][j] = MAXCOST;  
60.         }  
61.     }  
62.     //构建图G  
63.     for (k = 1; k <= n; k++)  
64.     {  
65.         in >> i >> j >> cost;  
66.         graph[i][j] = cost;  
67.         graph[j][i] = cost;  
68.     }  
69.     //求解最小生成树  
70.     cost = prim(graph, m);  
71.     //输出最小权值和  
72.     cout << "最小权值和=" << cost << endl;  
73.     system("pause");  
74.     return 0;  
75. }  

Input：

 

 

[plain]  view plain  copy

 

 print?

1. 6 10  
2. 1 2 6  
3. 1 3 1  
4. 1 4 5  
5. 2 3 5  
6. 2 5 3  
7. 3 4 5  
8. 3 5 6  
9. 3 6 4  
10. 4 6 2  
11. 5 6 6  

Output：

 

 

[plain]  view plain  copy

 

 print?

1. V1-V3=1  
2. V3-V6=4  
3. V6-V4=2  
4. V3-V2=5  
5. V2-V5=3  
6. 最小权值和=15  
7. 请按任意键继续. . .  

 

 

java实现：

/*
 * prim最小生成树
 *
 * 参数说明：
 *   start -- 从图中的第start个元素开始，生成最小树
 */
public void prim(int start) {
    int num = mVexs.length;         // 顶点个数
    int index=0;                    // prim最小树的索引，即prims数组的索引
    char[] prims  = new char[num];  // prim最小树的结果数组
    int[] weights = new int[num];   // 顶点间边的权值

    // prim最小生成树中第一个数是"图中第start个顶点"，因为是从start开始的。
    prims[index++] = mVexs[start];

    // 初始化"顶点的权值数组"，
    // 将每个顶点的权值初始化为"第start个顶点"到"该顶点"的权值。
    for (int i = 0; i < num; i++ )
        weights[i] = mMatrix[start][i];
    // 将第start个顶点的权值初始化为0。
    // 可以理解为"第start个顶点到它自身的距离为0"。
    weights[start] = 0;

    for (int i = 0; i < num; i++) {
        // 由于从start开始的，因此不需要再对第start个顶点进行处理。
        if(start == i)
            continue;

        int j = 0;
        int k = 0;
        int min = INF;
        // 在未被加入到最小生成树的顶点中，找出权值最小的顶点。
        while (j < num) {
            // 若weights[j]=0，意味着"第j个节点已经被排序过"(或者说已经加入了最小生成树中)。
            if (weights[j] != 0 && weights[j] < min) {
                min = weights[j];
                k = j;
            }
            j++;
        }

        // 经过上面的处理后，在未被加入到最小生成树的顶点中，权值最小的顶点是第k个顶点。
        // 将第k个顶点加入到最小生成树的结果数组中
        prims[index++] = mVexs[k];
        // 将"第k个顶点的权值"标记为0，意味着第k个顶点已经排序过了(或者说已经加入了最小树结果中)。
        weights[k] = 0;
        // 当第k个顶点被加入到最小生成树的结果数组中之后，更新其它顶点的权值。
        for (j = 0 ; j < num; j++) {
            // 当第j个节点没有被处理，并且需要更新时才被更新。
            if (weights[j] != 0 && mMatrix[k][j] < weights[j])
                weights[j] = mMatrix[k][j];
        }
    }

    // 计算最小生成树的权值
    int sum = 0;
    for (int i = 1; i < index; i++) {
        int min = INF;
        // 获取prims[i]在mMatrix中的位置
        int n = getPosition(prims[i]);
        // 在vexs[0...i]中，找出到j的权值最小的顶点。
        for (int j = 0; j < i; j++) {
            int m = getPosition(prims[j]);
            if (mMatrix[m][n]<min)
                min = mMatrix[m][n];
        }
        sum += min;
    }
    // 打印最小生成树
    System.out.printf("PRIM(%c)=%d: ", mVexs[start], sum);
    for (int i = 0; i < index; i++)
        System.out.printf("%c ", prims[i]);
    System.out.printf("\n");
}

 

转载于:https://www.cnblogs.com/sz-zzm/p/5553059.html