[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 = 200010, INF = 0x7f7f7f7f;

struct Edge_1 {
    int v, len, nex;
}edge_1[N << 2]; 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 << 1]; int top_2; // for sort kruskal

struct UFS {
    int fa[N * 3];
    inline void clear() {
        for(int i = 1; i < N * 3; 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 * 3]; // for dijkstra
int fa[N * 3][21], tot, h[N * 3]; // 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 = 0;
    top_2 = 0;
    memset(e, 0, sizeof(e));
    ufs.clear();
    return;
}

inline void dijkstra() {
    std::priority_queue<POI> Q;
    memset(dis, 0x3f, sizeof(dis));
    dis[1] = 0;
    Q.push(POI(1, 0)); // 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][0] = tot;
    fa[y][0] = 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 = 20;
    while(t >= 0) {
        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[0] = -1;
        for(int i = 1, 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 + 1, edge_2 + m + 1);
        for(int i = 1; i <= m; i++) {
            add(i);
        }
        for(int i = 1; i <= 20; i++) {
            for(int x = 1; x <= tot; x++) {
                fa[x][i] = fa[fa[x][i - 1]][i - 1];
            }
        }

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

170行代码还行。