[NOI2018]归程

今年D1T1，平心而论，如果能想到kruskal重构树还是很简单的。

......苟屁啊！虽然跟其他的比是简单些，但是思维难度中上，代码难度中上，怎么看都很符合NOI T1啊。

本题还有可持久化并查集的做法，以高度为版本。我没有打......

言归正传，来看题。

给你一个无向图，每条边有高度和长度。每次询问，从点s出发，只能经过高度大于h的边所能到达的点中，距1号点最近的点的距离。强制在线。

n<=200000,m<=400000,q<=400000

首先，离线有65分，十分可观。我们把边和询问都按照高度排序。然后依次加入，并查集维护连通块内dis最小值。

克鲁斯卡尔重构树解法：

首先讲什么是克鲁斯卡尔重构树：说起来也蛮简单，就是你把边排序，加边的时候如果连通就不加，否则新建节点代表这个连通块，边的两端所在连通块的代表节点作为这个新节点的两个子节点。

这样你要查询高度h时dis min，只需维护一个节点所代表连通块内dis最小值即可。每次向上跳，可以发现一条链上的dis min单调不增。然后就倍增了，类似lca。

啊我到底在口胡什么。

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

 const int N = , INF = 0x7f7f7f7f;

 struct Edge_1 {
     int v, len, nex;
 }edge_1[N << ]; int top_1; // for dijkstra

 struct POI {
     int id, dis;
     inline bool operator <(const POI &d) const {
         return dis > d.dis;
     }
     POI(int a, int b) {
         id = a;
         dis = b;
     }
 }; // for dijkstra

 struct Edge_2 {
     int u, v, h;
     inline bool operator <(const Edge_2 &d) const {
         return h > d.h;
     }
 }edge_2[N << ]; int top_2; // for sort kruskal

 struct UFS {
     int fa[N * ];
     inline void clear() {
         for(int i = ; i < N * ; i++) {
             fa[i] = i;
         }
         return;
     }
     UFS() {
         clear();
     }
     int find(int x) {
         if(fa[x] == x) {
             return x;
         }
         return fa[x] = find(fa[x]);
     }
     inline void merge(int x, int y) { // x <- y
         fa[find(y)] = find(x);
         return;
     }
 }ufs;

 int e[N], dis[N * ]; // for dijkstra
 int fa[N * ][], tot, h[N * ]; // for kruskal

 inline void add_1(int x, int y, int z) {
     top_1++;
     edge_1[top_1].v = y;
     edge_1[top_1].len = z;
     edge_1[top_1].nex = e[x];
     e[x] = top_1;
     return;
 }

 inline void add_2(int x, int y, int z) {
     top_2++;
     edge_2[top_2].u = x;
     edge_2[top_2].v = y;
     edge_2[top_2].h = z;
     return;
 }

 inline void clear() {
     top_1 = ;
     top_2 = ;
     memset(e, , sizeof(e));
     ufs.clear();
     return;
 }

 inline void dijkstra() {
     std::priority_queue<POI> Q;
     memset(dis, 0x3f, sizeof(dis));
     dis[] = ;
     Q.push(POI(, )); // POI(id, dis)
     while(!Q.empty()) {
         while(!Q.empty() && dis[Q.top().id] != Q.top().dis) {
             Q.pop();
         }
         if(Q.empty()) {
             break;
         }
         int x = Q.top().id;
         Q.pop();
         for(int i = e[x]; i; i = edge_1[i].nex) {
             int y = edge_1[i].v;
             if(dis[y] > dis[x] + edge_1[i].len) {
                 dis[y] = dis[x] + edge_1[i].len;
                 Q.push(POI(y, dis[y]));
             }
         }
     }
     return;
 }

 inline void add(int p) {
     int x = ufs.find(edge_2[p].u);
     int y = ufs.find(edge_2[p].v);
     if(x == y) {
         return;
     }
     ++tot;
     fa[x][] = tot;
     fa[y][] = tot;
     ufs.merge(tot, x);
     ufs.merge(tot, y);
     h[tot] = edge_2[p].h;
     dis[tot] = std::min(dis[x], dis[y]);
     return;
 }

 inline int solve(int x, int high) {
     int t = ;
     while(t >= ) {
         if(h[fa[x][t]] > high) {
             x = fa[x][t];
         }
         t--;
     }
     return dis[x];
 }

 int main() {
     int T;
     scanf("%d", &T);
     while(T--) {
         int n, m;
         scanf("%d%d", &n, &m);
         tot = n;
         h[] = -;
         for(int i = , x, y, z, w; i <= m; i++) {
             scanf("%d%d%d%d", &x, &y, &z, &w);
             add_1(x, y, z);
             add_1(y, x, z);
             add_2(x, y, w);
         }

         // prework
         dijkstra();
         std::sort(edge_2 + , edge_2 + m + );
         for(int i = ; i <= m; i++) {
             add(i);
         }
         for(int i = ; i <= ; i++) {
             for(int x = ; x <= tot; x++) {
                 fa[x][i] = fa[fa[x][i - ]][i - ];
             }
         }

         int q, k, s, op, high, la = ;
         scanf("%d%d%d", &q, &k, &s);
         while(q--) {
             scanf("%d%d", &op, &high);
             op = (op + k * la - ) % n + ;
             high = (high + k * la) % (s + );
             la = solve(op, high);
             printf("%d\n", la);
         }
         clear();
     }
     return ;
 }

AC代码

170行代码还行。