图-普利姆(Prime)算法

普利姆（Prime）算法（只与顶点相关）

      最近,重温图的一些算法。

      带权图分为有向和无向，构造连通网络最小代价(即连接各顶点路径权值之和最小)的最短路径又叫做最小生成树，有prime算法和kruskal算法，构造最小生成树一般使用贪心策略。

有向图的最短路径算法有dijkstra算法和floyd算法。


　　生成树的概念：联通图G的一个子图如果是一棵包含G的所有顶点的树，则该子图称为G的生成树 生成树是联通图的极小连通子图。所谓极小是指：若在树中任意增加一条边，则 将出现一个回路；若去掉一条边，将会使之编程非连通图。生成树各边的权 值总和称为生成素的权。权最小的生成树称为最小生成树，常用的算法有prime算法和kruskal算法。

算法描述：

普利姆算法求最小生成树时候，和边数无关，只和定点的数量相关，所以适合求稠密网的最小生成树，时间复杂度为O（n*n）。

算法过程：

1.将一个图的顶点分为两部分，一部分是最小生成树中的结点（A集合），另一部分是未处理的结点（B集合）。

2.首先选择一个结点，将这个结点加入A中，然后，对集合A中的顶点遍历，找出A中顶点关联的边权值最小的那个（设为v），将此顶点从B中删除，加入集合A中。

3.递归重复步骤2，直到B集合中的结点为空，结束此过程。

4.A集合中的结点就是由Prime算法得到的最小生成树的结点，依照步骤2的结点连接这些顶点，得到的就是这个图的最小生成树。

算法实现具体过程：

1.将第一个点放入最小生成树的集合中（标记visit[i]=1意思就是最小生成树集合）。

2.从第二个点开始，初始化lowcost[i]为跟1点相连（仅仅相连）的边的权值（lowcost[i]不是这个点的最小权值！在以后会逐步更新）。

3.找最小权值的边。

从第二点开始遍历，如果不是最小生成树的集合的点，则找出从2到n的最小权值（lowcost[j]）。

4.将找出来的最小权值的边的顶点加入最小生成树的集合中（标记visit[i] = 1），权值想加。

5.更新lowcost[j]集合。

假设第一次：lowcost[2]代表与1相连的点的权值，现在加入了k点。则比较k点与2点的边map[k][2]和lowcost[2]的大小，若lowcost[2]大，则lowcost[2] = map[k][2]。（关键步骤：实质就是每在最小生成树集合中加入一个点就需要把这个点与集合外的点比较，不断的寻找两个集合之间最小的边）

6.循环上述步骤，指导将全部顶点加入到最小生成树集合为止。

代码如下：

[cpp]  view plain  copy

1. #include<iostream>  
2. #include<cstdio>  
3. #include<cstring>  
4. #include<string>  
5. #include<algorithm>  
6. using namespace std;  
7. #define INF 0x3f3f3f3f  
8. #define MAXN 110  
9. int map[MAXN][MAXN], lowcost[MAXN];  
10. bool visit[MAXN];  
11. int nodenum, sum;  
12.   
13. void prim()  
14. {  
15.     int temp, k;  
16.     sum = 0;  
17.     memset(visit, false, sizeof(visit)); //初始化visit  
18.     visit[1] = true;  
19.     for(int i = 1; i <= nodenum; ++i) //初始化lowcost[i]  
20.         lowcost[i] = map[1][i];  
21.     for(int i = 1; i <= nodenum; ++i)//找生成树集合点集相连最小权值的边  
22.     {  
23.         temp = INF;  
24.         for(int j = 1; j <= nodenum; ++j)  
25.             if(!visit[j] && temp > lowcost[j])  
26.                 temp = lowcost[k = j];  
27.         if(temp == INF) break;  
28.         visit[k] = true; //加入最小生成树集合  
29.         sum += temp;//记录权值之和  
30.         for(int j = 1; j <= nodenum; ++j) //更新lowcost数组  
31.             if(!visit[j] && lowcost[j] > map[k][j])  
32.                 lowcost[j] = map[k][j];  
33.     }  
34. }  
35.   
36. int main()  
37. {  
38.     int a, b, cost, edgenum;  
39.     while(scanf("%d", &nodenum) && nodenum)  
40.     {  
41.         memset(map, INF, sizeof(map));  
42.         edgenum = nodenum * (nodenum - 1) / 2;  
43.         for(int i = 1; i <= edgenum; ++i) //输入边的信息  
44.         {  
45.             scanf("%d%d%d", &a, &b, &cost);  
46.             if(cost < map[a][b])  
47.                 map[a][b] = map[b][a] = cost;  
48.         }  
49.         prim();  
50.         printf("%d\n", sum); //最小生成树权值之和  
51.     }  
52.     return 0;  
53. }