【NOI 2018】归程（Kruskal重构树）

题面在这里就不放了。

同步赛在做这个题的时候，心里有点纠结，很容易想到离线的做法，将边和询问一起按水位线排序，模拟水位下降，维护当前的各个联通块中距离$1$最近的距离，每次遇到询问时输出所在联通块的信息。

离线的思路对满分做法有一定的启发性，很容易想到将并查集持久化一下就能支持在线了。

但是这个是两个$log$的，有卡常的风险也不是很方便写。

当时思考了一下就快速写完离线做法就去做其他题了。

对于这道题，有一个更好的做法：Kruskal重构树。

事实上如果你了解这个东西，那你就能很快的给出解，那仅此以这道题作为学习Kruskal重构树的例子。

先给出一个经典的模型：

• 给定一张无向图，每次询问两点之间所有简单路径中最大边权的最小值。

一个常规的做法就是建出最小生成树，答案就是树上路径的最大边权，正确性显然。

当然也可以用我们要讲的Kruskal重构树来解决，算法虽不同，思想类似。

Kruskal中我们连接两个联通块（子树）时直接用一条边将对应的两个点相连，但在Kruskal重构树中，我们先建一个虚点作为两个子树的树上父亲，让两个联通块分别与该点相连，注意的是要维护并查集合并时的有序性。

我们称新建的虚点为方点，代表了原图中的一条边，原图中的点为圆点，则该树有一些优雅的性质：

1. 这是一颗二叉树，并且相当于一个堆，因为边是有顺序合并的。
2. 最小生成树上路径的边权信息转化成了点权信息。

那么回顾刚刚的那个模型，每个询问就相当于回答Kruskal重构树上两点$lca$的权值。

最后在回来看这道题，就显得十分轻松了。

我们把每条边按照水位线从高到低依次插入，可以发现每次规定一个水位下限，车子能走的范围对应了Kruskal重构树上的一棵子树，那么每次只要倍增找到最紧的那个限制的点就可以了。

 #include <cstdio>
 #include <queue>
 #include <cstring>
 #include <algorithm>

 typedef long long LL;
 const int N = , INF = 2e9 + , LOG = ;

 int tc, n, m, Qi, k, s;
 int dis[N], flg[N], val[N], mdi[N], gr[LOG][N];
 std::priority_queue<std::pair<int, int> > Q;

 inline void Read(int &x) {
     x = ; static char c;
     for (c = getchar(); c < '' || c > ''; c = getchar());
     for (; c >= '' && c <= ''; x = (x << ) + (x << ) + c - '', c = getchar());
 }

 struct Edge {
     int u, v, a;
     inline friend bool operator < (Edge a, Edge b) {
         return a.a > b.a;
     }
 } e[N];

 int yun, las[N], to[N << ], pre[N << ], wi[N << ];
 inline void Add(int a, int b, int c = ) {
     to[++yun] = b; wi[yun] = c; pre[yun] = las[a]; las[a] = yun;
 }
 void Gragh_clear() {
     memset(gr, , sizeof gr);
     memset(las, , sizeof las);
     yun = ;
 }

 namespace DSU {
     int fa[N];
     void Init() {
         for (int i = ; i <= n + m; ++i) {
             fa[i] = i;
             if (i <= n) mdi[i] = dis[i], val[i] = -;
         }
     }
     int Seek(int x) {
         return (x == fa[x])? (x) : (fa[x] = Seek(fa[x]));
     }
     void Merge(int x, int y) {
         fa[Seek(y)] = x;
     }
 }

 void Dij() {
     for (int i = ; i <= n; ++i) {
         dis[i] = INF; flg[i] = ;
     }
     dis[] = ;
     Q.push(std::make_pair(, ));
     for (; !Q.empty(); ) {
         int x = Q.top().second; Q.pop();
         if (flg[x]) continue;
         flg[x] = ;
         for (int i = las[x]; i; i = pre[i]) {
             if (dis[to[i]] > dis[x] + wi[i]) {
                 dis[to[i]] = dis[x] + wi[i];
                 Q.push(std::make_pair(-dis[to[i]], to[i]));
             }
         }
     }
 }

 int main() {
     freopen("return.in", "r", stdin);
     freopen("return.out", "w", stdout);

     scanf("%d", &tc);
     for (; tc; --tc) {
         scanf("%d%d", &n, &m);
         Gragh_clear();
         for (int i = , x, y, a, l; i <= m; ++i) {
             //scanf("%d%d%d%d", &x, &y, &l, &a);
             Read(x); Read(y); Read(l); Read(a);
             Add(x, y, l); Add(y, x, l);
             e[i] = (Edge) { x, y, a };
         }
         Dij(); DSU::Init();

         std::sort(e + , e +  + m);
         for (int i = ; i <= m; ++i) {
             int x = DSU::Seek(e[i].u), y = DSU::Seek(e[i].v);
             if (x == y) continue;
             val[i + n] = e[i].a;
             mdi[i + n] = std::min(mdi[x], mdi[y]);
             DSU::Merge(i + n, x); DSU::Merge(i + n, y);
             gr[][x] = gr[][y] = i + n;
         }

         for (int i = ; i < LOG; ++i) {
             for (int j = ; j <= n + m; ++j) {
                 if (gr[i - ][j]) gr[i][j] = gr[i - ][gr[i - ][j]];
             }
         }

         scanf("%d%d%d", &Qi, &k, &s);
         for (int x, a, lans = ; Qi; --Qi) {
             //scanf("%d%d", &x, &a);
             Read(x); Read(a);
             x = (x + (LL) k * lans - ) % n + ;
             a = (a + (LL) k * lans) % (s + );
             for (int i = LOG - ; ~i; --i) {
                 if (gr[i][x] && val[gr[i][x]] > a) x = gr[i][x];
             }
             printf("%d\n", mdi[x]);
             lans = mdi[x];
         }
     }

     return ;
 }

$\bigodot$技巧＆套路：

• kruskal重构树的构建，最小生成树上最值问题的再探。