HDU 5253 连接的管道

题目：

Problem Description

老 Jack 有一片农田，以往几年都是靠天吃饭的。但是今年老天格外的不开眼，大旱。所以老 Jack 决定用管道将他的所有相邻的农田全部都串联起来，这样他就可以从远处引水过来进行灌溉了。当老 Jack 买完所有铺设在每块农田内部的管道的时候，老 Jack 遇到了新的难题，因为每一块农田的地势高度都不同，所以要想将两块农田的管道链接，老 Jack 就需要额外再购进跟这两块农田高度差相等长度的管道。

现在给出老 Jack农田的数据，你需要告诉老 Jack 在保证所有农田全部可连通灌溉的情况下，最少还需要再购进多长的管道。另外，每块农田都是方形等大的，一块农田只能跟它上下左右四块相邻的农田相连通。
 

 

Input

第一行输入一个数字T(T≤10) ，代表输入的样例组数

输入包含若干组测试数据，处理到文件结束。每组测试数据占若干行，第一行两个正整数 N,M(1≤N,M≤1000) ，代表老 Jack 有N行*M列个农田。接下来 N 行，每行 M 个数字，代表每块农田的高度，农田的高度不会超过100。数字之间用空格分隔。
 

 

Output

对于每组测试数据输出两行：

第一行输出："Case #i:"。i代表第i组测试数据。

第二行输出 1 个正整数，代表老 Jack 额外最少购进管道的长度。
 

 

Sample Input

2 4 3 9 12 4 7 8 56 32 32 43 21 12 12 2 3 34 56 56 12 23 4

思路：

　　   重点在于建图，只要图能建好，剩下的就是套用并查集&最小生成树的模板问题了。

  • n*m型的方块田，从左上角开始向右下角铺，那就向右和向下铺，这样不容易出错，也不容易混乱。建图过程的代码： 
     1 for(int i = 1; i <= n; i++)    //建图 
 2         {
 3             for(int j = 1; j <= m; j++)
 4             {
 5                 if(j + 1 <= m)    //向右铺管道，到边缘时不能再向右铺 
 6                 {
 7                     s[cnt].begin = i * m + j;
 8                     s[cnt].end = i * m + j + 1;
 9                     s[cnt].len = abs(map[i][j] - map[i][j + 1]); 
10                     cnt++;
11                 }
12                 if(i + 1 <= n)    //向下铺管道 
13                 {
14                     s[cnt].begin = i * m + j;
15                     s[cnt].end = (i + 1) * m + j;
16                     s[cnt].len = abs(map[i][j] - map[i + 1][j]); 
17                     cnt++;
18                 }
19             }
20          }

     

完整代码：

 1 #include <iostream>
 2 #include <algorithm>
 3 #include <cmath>
 4 #include <cstring>
 5 using namespace std;
 6 #define MAXN 1005
 7 
 8 int map[MAXN][MAXN];    //存储每块田的高度 
 9 int pre[5000000];
10 
11 struct node{
12     int begin;
13     int end;
14     int len; 
15 }s[5000000];
16 
17 bool cmp(node a, node b)
18 {
19     return a.len < b.len;
20 }
21 
22 void init(int a, int b)    //初始化成独立结点 
23 {
24     for(int i = 0; i <= a * b * 2; i++)
25     {
26         pre[i] = i;
27      } 
28 } 
29 
30 int find(int x)    //路径压缩 
31 {
32     if(x != pre[x])        //从x结点搜索到根结点所经过的结点都指向该根结点
33         pre[x] = find(pre[x]);    //回溯时的压缩路径
34     return pre[x];
35 }
36 
37 int kruskal(int cnt)
38 {
39     int minlen = 0;
40     sort(s, s + cnt, cmp);
41     for(int i = 0; i < cnt; i++)    //判断边所对的两个结点是否属于同一根节点，不是则合并，计入边长
42     {
43         int fx = find(s[i].begin);
44         int fy = find(s[i].end);
45         if(fx != fy)
46         {
47             pre[fx] = fy;
48             minlen += s[i].len;
49         }
50     }
51     return minlen;
52 }
53 
54 int main()
55 {
56     int t, n, m;
57     cin >> t;
58     for(int k = 1; k <= t; k++)
59     {
60         scanf("%d%d", &n, &m);
61         init(n, m);
62         for(int i = 1; i <= n; i++)
63         {
64             for(int j = 1; j <= m; j++)
65             {
66                 scanf("%d", &map[i][j]);
67             }
68         }
69         int cnt = 0;
70         for(int i = 1; i <= n; i++)    //建图 
71         {
72             for(int j = 1; j <= m; j++)
73             {
74                 if(j + 1 <= m)    //向右铺管道，到边缘时不能再向右铺 
75                 {
76                     s[cnt].begin = i * m + j;
77                     s[cnt].end = i * m + j + 1;
78                     s[cnt].len = abs(map[i][j] - map[i][j + 1]); 
79                     cnt++;
80                 }
81                 if(i + 1 <= n)    //向下铺管道 
82                 {
83                     s[cnt].begin = i * m + j;
84                     s[cnt].end = (i + 1) * m + j;
85                     s[cnt].len = abs(map[i][j] - map[i + 1][j]); 
86                     cnt++;
87                 }
88             }
89          }
90          int minlen = kruskal(cnt);
91         printf("Case #%d:\n%d\n", k, minlen);
92     }
93     return 0;
94  }

总结：

  • 只有知道自己跌倒在什么地方，才能在那个地方爬起来继续往前，不然只会原地打滚。
  1. 刚开始一直TLE，首先是输入问题，cin输入比scanf要来得慢，之前我也搜过这样的比较文章，尤其是大量数据输入的情况下，cin会比scanf慢很多，虽知如此，面对图论相关的题我也没有优先使用scanf，这就是一点不对的地方。当然不是说cin不好，各有优劣，比如在输入字符串时，要用到string类型啊啥的时候，用cin就会比scanf来得方便且不容易出错。
  2. 数组大小问题，刚开始数组只开了1000000，一百万吧。太小了，根据建图过程： 
     1 for(int i = 1; i <= n; i++)    //建图 
 2         {
 3             for(int j = 1; j <= m; j++)
 4             {
 5                 if(j + 1 <= m)    //向右铺管道，到边缘时不能再向右铺 
 6                 {
 7                     s[cnt].begin = i * m + j;
 8                     s[cnt].end = i * m + j + 1;
 9                     s[cnt].len = abs(map[i][j] - map[i][j + 1]); 
10                     cnt++;
11                 }
12                 if(i + 1 <= n)    //向下铺管道 
13                 {
14                     s[cnt].begin = i * m + j;
15                     s[cnt].end = (i + 1) * m + j;
16                     s[cnt].len = abs(map[i][j] - map[i + 1][j]); 
17                     cnt++;
18                 }
19             }
20          }

     n*m里一次要存两条边，少说也得开个2*n*m，两百万吧，结果才开一百万，数组又不是开不到这么大，还能开更大呢，所以何必这么不舍得开数组？？？不过因为少开数组也学到了一些东西，知道了数组少开的情况下，运行结果会出错，所以这种最小生成树如果会WA，很有可能就是数组开小了。

 

 

posted @ 2019-07-07 23:23  Anzer  阅读(195)  评论(0)  编辑  收藏  举报