其他分享
首页 > 其他分享> > Luogu P1967 NOIP2013 货车运输

Luogu P1967 NOIP2013 货车运输

作者：互联网

　　这个题是很经典的生成树问题。第一次接触时对倍增算法的理解还不够透彻，没能打出来正解。

　　首先，原题中给出的是一幅图，询问从某点出发到另一点“需要经过的最短边的最大值”。用floyd来解决是可以的，但是数据范围不能承受O(n^3)的复杂度。于是我们考虑：假设原图是连通的，那么我们从某点到另一点，一定至少存在一条路径；而明显有一条路径是最优的，满足它所经过的最小边最大。既然这样，我们能不能把这条路径找出来呢？于是我们想对原图做一些处理。新的图应该满足：

　　1. 图仍是连通的。

　　2. 任意两点间的一条路径满足上述最优条件。

　　于是我们想到了生成树。从贪心的角度考虑，两点之间一定有一条这样的最优路径是最大生成树上的唯一路径。说明：因为最大生成树外的一条边一定小于等于树上的边权，那么它不可能比这条树上路径更优。

　　求出MST后，我们要维护的是树上路径的最小值信息。路径本身可以用LCA来搞，可是路径上的信息怎么预处理呢？联想ST算法，我们虽然不能维护任意两点间的信息，但是可以用倍增的思想，维护w(i, k)表示节点i到它的2^k代祖先所需经过的最短路径。w(i, 0)就是生成树上该点入边的权，然后按k从小到大转移，转移方程w(i, k) = min(w(i, k - 1), w(f[i][k-1], k-1))。其中f数组是按倍增法求LCA记录的祖先信息。最后查询时，所求的ans随LCA倍增算法更新最小值即可。

　　注意原图是不连通的，我们生成的实际上是一个森林，kruscal算法里维护的并查集可以帮助判断两个点是否在一个联通块内。

代码：

  1. #include <iostream>  
  2. #include <cstdio>  
  3. #include <cstring>  
  4. #include <cctype>  
  5. #include <algorithm>  
  6. #define maxn 10010  
  7. #define maxm 50010  
  8. #define inf (int)2e9  
  9. using namespace std;  
  10. template <typename T>   
  11. void read(T &x) {  
  12.     x = 0;  
  13.     char ch = getchar();  
  14.     while (!isdigit(ch)) ch = getchar();  
  15.     while (isdigit(ch)) {  
  16.         x = x * 10 + (ch ^ 48);  
  17.         ch = getchar();  
  18.     }  
  19.     return;  
  20. }  
  21. int n, m, q;  
  22. int head[maxn], top = 1;  
  23. struct E {  
  24.     int to, nxt, w;  
  25. } edge[maxn << 1];  
  26. struct pE {  
  27.     int u, v, w;  
  28. } pedge[maxm];  
  29. bool cmp(pE a, pE b) {  
  30.     return a.w > b.w;  
  31. }  
  32. inline void insert(int u, int v, int w) {  
  33.     edge[++top] = (E) {v, head[u], w};  
  34.     head[u] = top;  
  35. }  
  36. namespace UFS {  
  37.     int fa[maxn], rk[maxn];  
  38.     void init1() {  
  39.         for (int i = 1; i <= n; ++i)  
  40.             fa[i] = i;  
  41.     }  
  42.     int find(int x) {  
  43.         if (fa[x] == x) return x;  
  44.         return fa[x] = find(fa[x]);  
  45.     }  
  46.     bool Union(int u, int v) {  
  47.         u = find(u), v = find(v);  
  48.         if (u == v) return false;  
  49.         if (rk[u] < rk[v]) swap(u, v);  
  50.         fa[v] = u;  
  51.         rk[u] = max(rk[u], rk[v] + 1);  
  52.         return true;  
  53.     }  
  54. } using namespace UFS;  
  55. void kruscal() {  
  56.     init1();  
  57.     sort(pedge + 1, pedge + 1 + m, cmp);  
  58.     for (int i = 1, cnt = 0; i <= m && cnt < n - 1; ++i) {  
  59.         int u = pedge[i].u, v = pedge[i].v, w = pedge[i].w;  
  60.         if (Union(u, v)) {  
  61.             insert(u, v, w), insert(v, u, w);  
  62.             ++cnt;  
  63.         }  
  64.     }  
  65. }  
  66. namespace LCA {  
  67.     const int LG(14);  
  68.     int w[LG+2][maxn], f[LG+2][maxn], d[maxn];  
  69.     bool vis[maxn];  
  70.     void dfs(int u, int pre, int depth) {  
  71.         d[u] = depth;  
  72.         f[0][u] = pre;  
  73.         vis[u] = true;  
  74.         for (int i = head[u]; i; i = edge[i].nxt) {  
  75.             int v = edge[i].to;  
  76.             if (vis[v]) continue;  
  77.             w[0][v] = edge[i].w;  
  78. //          cout << w[0][v];  
  79.             dfs(v, u, depth + 1);  
  80.         }  
  81.     }  
  82.     void init2() {  
  83.         for (int i = 1; i <= n; ++i) {  
  84.             if (vis[i]) continue;  
  85.             dfs(i, 0, 1);  
  86.         }  
  87.         for (int k = 1; k <= LG; ++k)  
  88.             for (int i = 1; i <= n; ++i) {     
  89.                 f[k][i] = f[k-1][f[k-1][i]];  
  90.                 w[k][i] = min(w[k-1][i], w[k-1][f[k-1][i]]);  
  91. //              cout <<w[k][i];  
  92.             }  
  93.     }  
  94.     int query(int u, int v) {  
  95.         if (find(u) != find(v)) return -1;  
  96.         int ans = inf;  
  97.         if (d[u] > d[v]) swap(u, v);  
  98.         int del = d[v] - d[u];  
  99.         for (int i = 0; del; ++i, del >>= 1)  
  100.             if (del & 1)   
  101.                 ans = min(ans, w[i][v]), v = f[i][v];  
  102.         if (u == v) return ans;  
  103.         for (int i = LG; i >= 0; --i)  
  104.             if (f[i][u] != f[i][v]) {   
  105.                 ans = min(ans, min(w[i][u], w[i][v]));  
  106.                 u = f[i][u], v = f[i][v];  
  107.             }  
  108.         return min(ans, min(w[0][u], w[0][v]));  
  109.     }  
  110. } using namespace LCA;   
  111. int main() {  
  112.     read(n), read(m);  
  113.     int u, v, w;  
  114.     for (int i = 1; i <= m; ++i) {  
  115.         read(u), read(v), read(w);  
  116.         if (u != v)  
  117.             pedge[i] = (pE) {u, v, w};  
  118.     }  
  119.     kruscal();  
  120.     init2();  
  121.     read(q);  
  122.     while (q--) {  
  123.         read(u), read(v);  
  124.         printf("%d\n", query(u, v));  
  125.     }  
  126.     return 0;  
  127. }  

PS：看了这个题以后觉得树剖貌似是个好东西，有空学习一个。

标签：return,int,Luogu,路径,货车运输,read,maxn,ans,P1967
来源： https://www.cnblogs.com/TY02/p/11132814.html