1251 Jungle Roads 解题报告

AccecptTime:          2008-12-18 12:04:07 2008-12-18 12:24:03
Language:                 c++
Memory:                  292K 292K
Time:                       0 MS
Errors:                      3 RE
Algorithm:               最小生成树 Kruskal + Prim

 

 

1. 1. //这段代码用的是Kruskal算法,用到了并查集
   3. #include <stdio.h>
   4. #include <stdlib.h>
   5. #include <memory.h>
   6. #include <iostream>
   7. using namespace std;
   8. typedef struct Edge{
   9.     int x;
   10.     int y;
   11.     int weigh;
   12. }Edge;
   13. Edge edge[1000];
   14. int parent[100];
   15. //寻找父节点
   16. int FindParent(int x)
   17. {
   18.     if(parent[x])
   19.         parent[x] = FindParent(parent[x]);
   20.     else
   21.         return x;
   22.     return parent[x];
   23. }
   24. //并查集合并
   25. void MergeSet(int x, int y)
   26. {
   27.     int t1 = FindParent(x);
   28.     int t2 = FindParent(y);
   29.     if( t1 > t2)
   30.         parent[t2] = t1;
   31.     else
   32.         parent[t1] = t2;
   33. }
   34. //用于qsort()的比较函数
   35. int compare(const void* a,const void* b)
   36. {
   37.     return ((Edge*)a)->weigh - ((Edge*)b)->weigh;
   38. }
   39. int main()
   40. {
   41.     int n, count;
   42.     char x,y;
   43.     int v, weigh, sum;
   44.     cin >> n;
   45.     while( n) {
   46.         getchar();
   47.         count = sum = 0;
   48.         for( int i = 0; i < n - 1; i++) {
   49.             cin >> x >> v;
   50.             x = x - 'A' + 1;
   51.             for( int j = 0; j < v; j++) {
   52.                 cin >> y >>weigh;
   53.                 y = y - 'A' + 1;
   54.                 edge[count].x = x;
   55.                 edge[count].y = y;
   56.                 edge[count++].weigh = weigh;
   57.             }
   58.             getchar();
   59.         }
   60.         qsort(edge,count,sizeof(Edge),compare);
   61.         //对并查集进行初始化
   62.         memset(parent,0,27 * sizeof(int));
   63.         for(int i = 0; i < count; i++)
   64.             //判断两个节点是否在同一个集合
   65.             if(FindParent(edge[i].x) != FindParent(edge[i].y)) {
   66.                 sum += edge[i].weigh;
   67.                 MergeSet(edge[i].x,edge[i].y);
   68.             }
   69.         cout << sum << endl;
   70.         cin >> n;
   71.     }
   72. }
   //这用的是Prim算法
3. #include <iostream>
4. using namespace std;
5. //记录集合的元素
6. int in[26];
7. //路径储存
8. int road[26][26];
9. //记录是否在集合内
10. int inv[26];
11. int main()
12. {
13.     int n, v, weigh;
14.     int min,mink,j;
15.     char x, y;
16.     cin >> n;
17.     while(n) {
18.         int sum = 0;
19.         for( int i = 0; i < 26; i++)
20.             for( int j = 0; j < 26; j++)
21.                 road[i][j] = 0;
22.         memset(inv,0,26 * sizeof(int));
23.         for( int i = 0; i < n - 1; i++) {
24.             cin >> x >> v;
25.             x -= 'A';
26.             for( int j = 0; j < v; j++) {
27.                 cin >> y >> weigh;
28.                 y -= 'A';
29.                 road[x][y] = road[y][x] = weigh;
30.             }
31.         }
32.         in[0] = 0;
33.         inv[0] = 1;
34.         for( int i = 1; i < n; i++) {
35.             min = 99999999;
36.             for(j = 0; j < i; j++)
37.                 for( int k = 0; k < n; k++)
38.                     // 先判断节点是否已经加入,再判断路径是否存在,再判断路径是否最小
39.                     if(!inv[k] && road[(in[j])][k] && road[(in[j])][k] < min) {
40.                         min = road[in[j]][k];
41.                         mink = k;
42.                     }
43.             //将mink点加入集合,并标记
44.             in[j] = mink;
45.             inv[mink] = 1;
46.             sum += min;
47.         }
48.         cout << sum << endl;
49.         cin >> n;
50.     }
51. }

这道题考察的是最小生成树,我分别用Kruskal 和 Prim 解出,发现内存使用和时间都是一样,但是一向低效的Prim只用了Kruskal一半多的代码(囧..),另外这道题输入很bt(在行尾会有多余空格),导致了3 RE,下次能用cin的时候要用cin。这题写得有点慢..下次遇见的时候应该直接秒杀~~