Prim算法 （改进）

前几篇文章,发的都是Prim算法差不多O(n^3)的时间复杂度,其实标准的Prim算法，时间复杂度是O(n^2),所以需要改进，Prim算法就是U集合的增大和V-U集合的减少，总共要进行n-1次地把点从 V-U集合添加到U集合中,直到U集合中含有n个点为止。

如图：

 

 

1. #include<iostream>
2. #include<cstdio>
3. #include<vector>
4. #include<string>
5. #include <cstdlib>
6. using namespace std;
7. const int MAX = 2001;
8. const int INF = 100;
9. int c[MAX][MAX];
10. int closet[MAX];//记录的是V-U集合连接到U集合中,最小的边，包含在U中的顶点 
11. int lowcost[MAX];
12. char ss[MAX][7];
13. bool flag[MAX];
14. int Prim(int n)
15. {
16.     int i, j, k, ans = 0, pair = 0;
17.     flag[1] = true;
18.     for(i = 2; i <= n; i++)
19.     {
20.         lowcost[i] = c[1][i];
21.         closet[i] = 1;
22.         flag[i] = false;
23.     }
24.     for(i = 1; i < n; i++)
25.     {
26.         j = 1;
27.         int min = INF;
28.         //遍历V-U集合,找到最小的lowcost 
29.         for(k = 2; k <=n; k++)
30.         {
31.             if(lowcost[k] < min && !flag[k])
32.             {
33.                 min = lowcost[k];
34.                 j = k;
35.             }
36.         }
37.         flag[j] = true;
38.         //j<--->closet[j]表示新加入的这条边的长度 
39.         ans += c[j][closet[j]];
40.         //重新计算V-U集合 到 U集合之间的 lowcost 
41.         for(k = 2; k <= n; k++)
42.         {
43.             if(c[j][k] < lowcost[k] && !flag[k])
44.             {
45.                 lowcost[k] = c[j][k];
46.                 //为以后加入到U集合预先准备 k<--->closet[k]表示新加入的一条边 
47.                 closet[k] = j;
48.             }
49.         }
50.     }
51.     return ans;
52. }