CCF-CSP 201812-4 数据中心（Kruskal最小生成树）

Kruskal最小生成树

　　思路：题目要求的传输图是树结构，所以是生成树问题。另外一方面，咱们将会看到最优解就是最小生成树。

　　题中“传输图”的传输时间实质上为连通路径上的最大传输时间。咱们发现当生成树上传输时间总和最小时，其中的最大传输时间也最小（传输时间不为负值，因此最大传输时间<传输时间总和，再放缩一下即得）。 所以所求最优解就是是原图的最小生成树。

　　Kruskal算法实际上是一种贪心算法，每次都选取权值小的边去构造生成树，使得最终的生成树边权总和最小。若新加入的边会产生环，使得结果再也不知足树的性质，则应当丢弃该边，能够经过判断边两端的顶点是否在同一连通份量中实现这种判断，通常采用并查集完成。

　　根据生成树性质，当恰有N-1条边加入到生成树中时，生成树构造完毕。（N为顶点个数）。采用并查集后，只剩下1个集合时树构造完成。

 

AC代码：

  1 /*
  2  * 1. 若定义变量名rank，则CSP报编译出错，改成rank_1后经过。缘由未知！
  3  * 
  4  * 2. 题中“树结构传输图”的传输时间实质上为连通路径上最大的传输时间。目标是求使总传输时间最小的树： 
  5  *        当连通路径上传输时间总和最小时，其中的最大传输时间也最小（传输时间不为负值）。 
  6  *        所以所求“最优结构”是原图的最小生成树。 
  7  * 3. 使用kruskal算法时，基于题目所给出的数据规模，应对并查集采用简单的按秩合并优化或者路径压缩。 
  8  *        秩增长的惟一条件是：两个集合对应子树的秩相等。由于合并集合时，
  9  *        老是将秩小的树合并到秩大的树上，总秩不会发生任何改变，除非两树等秩时，才使总秩增长1。 
 10  *        本例实测，单纯使用简单按秩合并优化后，执行时间为原来的 1/40！
 11  * 4. 还可考虑路径压缩算法，即每次father()搜索时，将被查找过的节点的parent都指向它们的直接根节点。
 12  *        递归实现：Line 45。
 13  *        本例实测，单纯使用路径压缩优化后，执行时间为原来的 1/40！  
 14  */
 15  
 16 #include <iostream>
 17 #include <algorithm>
 18 
 19 #include <fstream>
 20 
 21 struct Edge {
 22     int u, v;
 23     int t;
 24     
 25     inline bool operator < (const Edge &e) const {
 26         return t < e.t;
 27     }
 28     inline bool operator ==(const Edge &e) const {
 29         return u==e.u || v==e.v;
 30     }
 31 };
 32 
 33 using namespace std;
 34 
 35 static int *parent;
 36 static int *rank_1;
 37 
 38 static int father(int p) {
 39 #if 0  // not optimized 
 40     while (parent[p] != p) {
 41         p = parent[p];
 42     }
 43     return p;
 44 #else
 45     return (parent[p] == p) ? p : (parent[p] = father(parent[p]));
 46 #endif 
 47 }
 48 
 49 int main(void) {
 50     ios::sync_with_stdio(false);
 51     
 52 /*#if 0 
 53     ifstream fin("input.txt");
 54     cin.rdbuf(fin.rdbuf());
 55 #endif*/ 
 56     
 57     int n, m, root;
 58     cin >> n >> m >> root;
 59     
 60     Edge *e = new Edge[m];
 61     parent = new int[n+1];
 62     rank_1 = new int[n+1];
 63     
 64     for(int i=0; i<m; ++i) {
 65         cin >> e[i].v >> e[i].u >> e[i].t;
 66     }
 67     for(int i=1; i<=n; ++i) {
 68         parent[i] = i;
 69         rank_1[i] = 1;
 70     }
 71     
 72     sort(e, e+m);
 73     
 74     int k = 0;
 75     int ans = 0;
 76     
 77     father(e[0].u);
 78     
 79     for(int i=0; i<m; ++i) {
 80         int pv = father(e[i].v);
 81         int pu = father(e[i].u);
 82         if (pv != pu) {
 83             if (rank_1[pv] < rank_1[pu]) {
 84                 parent[pv] = pu; // union pv -> pu 
 85             }
 86             else {
 87                 parent[pu] = pv; // union pu -> pv
 88                 if (rank_1[pu] == rank_1[pv]) {
 89                     ++rank_1[pv];
 90                 }
 91             }
 92             
 93             ++k;
 94             
 95             if (e[i].t > ans) {
 96                 ans = e[i].t;
 97             }
 98         }
 99         if (k==n-1) break;
100     }
101     
102     cout << ans << endl;
103     
104     return 0;
105 } 

 

PS:

1. 解题时遇到一个罕见的问题：

　　若在程序中定义标识符rank，则CSP报编译错误。改成rank_1等标识符后经过。

这多是因为判题系统占用了rank这个标识符，致使编译时出现重定义错误。

 

2. 传输时间为什么是路径上的最大时间？

　　能够参考流水线实现，即各个节点的收发是异步的，对于一个节点，并非待全部数据都接收完毕后，再将收到的数据发送出去。这相似于双端口缓存，写端口（接收端送来数据）和读端口（传输至发送端）同时以不一样的速率写入和读出数据。