Building Roads

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 9360		Accepted: 2690

Farmer John had just acquired several new farms! He wants to connect the farms with roads so that he can travel from any farm to any other farm via a sequence of roads; roads already connect some of the farms.

Each of the N (1 ≤ N ≤ 1,000) farms (conveniently numbered 1..N) is represented by a position (Xi, Yi) on the plane (0 ≤ Xi ≤ 1,000,000; 0 ≤ Yi ≤ 1,000,000). Given the preexisting M roads (1 ≤ M ≤ 1,000) as pairs of connected farms, help Farmer John determine the smallest length of additional roads he must build to connect all his farms.

* Line 1: Two space-separated integers: N and M
* Lines 2..N+1: Two space-separated integers: Xi and Yi 
* Lines N+2..N+M+2: Two space-separated integers: i and j, indicating that there is already a road connecting the farm i and farm j.

* Line 1: Smallest length of additional roads required to connect all farms, printed without rounding to two decimal places. Be sure to calculate distances as 64-bit floating point numbers.

4 1
1 1
3 1
2 3
4 3
1 4

4.00实现如下：

 1 #include <iostream>
 2 #include <cmath>
 3 #include <cstring>
 4 #include <cstdio>
 5 #define INF 0x3f3f3f3f
 6 using namespace std;
 7 const int N = 1001;
 8 double graph[N][N];
 9 bool visit[N];
10 int n,M;
11 typedef struct
12 {
13     double x;
14     double y;
15 }dian;
16 dian m[N];
17
18 double prim()
19 {
20
21     memset(visit,0,sizeof(visit));
22
23     double low[1001];
24     int pos = 1;
25     visit[1] = 1;
26     double result = 0;
27
28     for(int i = 2; i <= n; i++)
29     {
30         low[i] = graph[pos][i];
31     }
32
33     for(int i = 0; i < n-1; i++)
34     {
35         double Min = INF;
36
37         for(int j = 1; j <= n; j++)
38         {
39             if(!visit[j] && Min > low[j])
40             {
41                 Min = low[j];
42                 pos = j;
43
44             }
45         }
46         visit[pos] = 1;
47         result += Min;
48
49         for(int i = 1; i <= n; i++)
50         {
51             if(!visit[i] && low[i] > graph[pos][i])
52             {
53                 low[i] = graph[pos][i];
54             }
55         }
56
57     }
58     return result;
59 }
60
61 double dis(dian a,dian b)
62 {
63     return sqrt((a.x - b.x)*(a.x - b.x) + (a.y - b.y)*(a.y - b.y));
64 }
65
66 int main()
67 {
68    // freopen("in.txt","r",stdin);
69     while(cin>>n>>M)
70     {
71         memset(graph,INF,sizeof(graph));
72         for(int i = 1; i <=n;i++)
73         {
74             cin >> m[i].x>>m[i].y;
75         }
76         for(int i = 1; i <= n; i++)
77         {
78             for(int j = i + 1; j <= n; j++)
79             {
80                 graph[i][j] = graph[j][i] = dis(m[i],m[j]);
81             }
82         }
83         for(int i = 0; i < M ; i++)
84         {
85             int a,b;
86             cin>>a>>b;
87             graph[a][b] = graph[b][a] = 0;
88         }
89         printf("%.2lf\n",prim());
90     }
91     return 0;
92 }  

求加权连通图的最小生成树的算法。kruskal算法总共选择n- 1条边，所使用的贪婪准则是：从剩下的边中选择一条不会产生环路的具有最小耗费的边加入已选择的边的集合中。注意到所选取的边若产生环路则不可能形成一棵生成树。kruskal算法分e 步，其中e 是网络中边的数目。按耗费递增的顺序来考虑这e 条边，每次考虑一条边。当考虑某条边时，若将其加入到已选边的集合中会出现环路，则将其抛弃，否则，将它选入。

  1 #include <iostream>
  2 #include <cstdio>
  3 #include <cmath>
  4 #include <cstring>
  5 #include <algorithm>
  6 using namespace std;
  7 const int N = 1001;
  8 const int E = 1000000;
  9 int n, M;
 10 int cent;
 11 int a[N];
 12 int Count = 0;
 13
 14 typedef struct
 15 {
 16     int x;
 17     int y;
 18     double vaule;
 19 }dian;
 20 dian m[E];
 21
 22 typedef struct
 23 {
 24     double x, y;
 25 }situation;
 26 situation p[N];
 27
 28 double dis(situation a, situation b)
 29 {
 30     return sqrt((a.x - b.x)*(a.x - b.x) + (a.y - b.y) * (a.y - b.y));
 31 }
 32
 33 bool cmp(dian a, dian b)
 34 {
 35     return a.vaule < b.vaule;
 36 }
 37
 38 void init()
 39 {
 40     //                   cent 这里应该初始化到n
 41     for (int i = 1; i <= n; i++)
 42     {
 43         a[i] = i;
 44     }
 45 }
 46
 47 int Find(int x)
 48 {
 49     while (x != a[x])
 50     {
 51         x = a[x];
 52     }
 53     return x;
 54 }
 55
 56 void Union(int x, int y)
 57 {
 58     // 建议做路径压缩
 59     int fx = Find(x);
 60     int fy = Find(y);
 61     if (fx != fy)
 62     {
 63         a[fx] = fy;
 64     }
 65 }
 66 //kruskal模板
 67 double Kruskal()
 68 {
 69     // init(); 不应该在这里init
 70     sort(m, m + cent, cmp);
 71     double result = 0;
 72     for (int i = 0; i < cent&&Count != n - 1; i++)
 73     {
 74         if (Find(m[i].x) != Find(m[i].y))
 75         {
 76             Union(m[i].x, m[i].y);
 77             result += m[i].vaule;
 78             Count++;
 79         }
 80     }
 81     return result;
 82 }
 83
 84 int main()
 85 {
 86     while (cin >> n >> M)
 87     {
 88
 89         for (int i = 1; i <= n; i++)
 90         {
 91             cin >> p[i].x >> p[i].y;
 92         }
 93         cent = 0;
 94         Count = 0;
 95         for (int i = 1; i <= n; i++)
 96         {
 97             for (int j = i + 1; j <= n; j++)
 98             {
 99                 m[cent].x = i;
100                 m[cent].y = j;
101                 m[cent++].vaule = dis(p[i], p[j]);
102             }
103         }
104         // init不应该放在Kruskal里面
105         init();
106         for (int i = 1; i <= M; i++)
107         {
108             int a, b;
109             cin >> a >> b;
110             // 这里还是要检查Find a 和 Find b是不是一样，不然Count会错
111             if (Find(a) != Find(b)) {
112                 Union(a, b);
113                 Count++;
114             }
115         }
116
117         printf("%.2f\n", Kruskal());
118     }
119     return 0;
120 }