【NOI2018】归程（可持久化并查集，Dijkstra）

Description

https://www.luogu.org/problemnew/show/P4768

---

Solution

如果没有强制在线，我们先预处理出距离1的最短路，将询问和边按海拔从大到小依次加入，用并查集维护当前联通块内距离1最近的点即可。

如果强制在线，用可持久化并查集启发式合并即可，时间复杂度$O(n\log^2 n)$，用Kruskal重构树可以做到一个$\log$。

还有一件事：
“
$\huge{关于\mathrm{SPFA}}$

• 它死了

”

---

Code

// luogu-judger-enable-o2
/************************************************
 * Au: Hany01
 * Prob: return
 * Email: hany01@foxmail.com
 * Inst: Yali High School
************************************************/

#include<bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int, int> PII;
#define File(a) freopen(a".in", "r", stdin), freopen(a".out", "w", stdout)
#define rep(i, j) for (register int i = 0, i##_end_ = (j); i < i##_end_; ++ i)
#define For(i, j, k) for (register int i = (j), i##_end_ = (k); i <= i##_end_; ++ i)
#define Fordown(i, j, k) for (register int i = (j), i##_end_ = (k); i >= i##_end_; -- i)
#define Set(a, b) memset(a, b, sizeof(a))
#define Cpy(a, b) memcpy(a, b, sizeof(a))
#define x first
#define y second
#define pb(a) push_back(a)
#define mp(a, b) make_pair(a, b)
#define ALL(a) (a).begin(), (a).end()
#define SZ(a) ((int)(a).size())
#define INF (0x3f3f3f3f)
#define INF1 (2139062143)
#define debug(...) fprintf(stderr, __VA_ARGS__)
#define y1 wozenmezhemecaia

template <typename T> inline bool chkmax(T &a, T b) { return a < b ? a = b, 1 : 0; }
template <typename T> inline bool chkmin(T &a, T b) { return b < a ? a = b, 1 : 0; }

inline int read() {
    static int _, __; static char c_;
    for (_ = 0, __ = 1, c_ = getchar(); c_ < '0' || c_ > '9'; c_ = getchar()) if (c_ == '-') __ = -1;
    for ( ; c_ >= '0' && c_ <= '9'; c_ = getchar()) _ = (_ << 1) + (_ << 3) + (c_ ^ 48);
    return _ * __;
}

const int maxn = 2e5 + 5, maxm = 4e5 + 5, maxq = 4e5 + 5;

int dis[maxn], beg[maxn], v[maxm << 1], nex[maxm << 1], w[maxm << 1], Q, K, S, ls[maxm], tot, v0, p0, e, n, m, vis[maxn], lastans;

struct Edge {
    int u, v, l, a;
    bool operator < (const Edge& A) { return a > A.a; }
}E[maxm];

struct DSU {
    vector<PII> a[maxn];
    void init() { For(i, 1, n) a[i].clear(); }
    void push(int pos, PII ne) {
        if (a[pos].begin() == a[pos].end()) a[pos].pb(ne);
        else {
            if ((*--a[pos].end()).x == ne.x) a[pos].erase(--a[pos].end());
            a[pos].pb(ne);
        }
    }
    int at(int tim, int pos) { return ((*--lower_bound(ALL(a[pos]), mp(tim + 1, -1)))).y; }
}fa, sz, mn;

inline void add(int uu, int vv, int ww) { v[++ e] = vv, w[e] = ww, nex[e] = beg[uu], beg[uu] = e; }

/*inline void SP() {
    static queue<int> q;
    Set(dis, 127), dis[1] = 0, q.push(1);
    while (!q.empty()) {
        int u = q.front(); vis[u] = 0, q.pop();
        for (register int i = beg[u]; i; i = nex[i])
            if (chkmin(dis[v[i]], dis[u] + w[i]))
                if (!vis[v[i]]) q.push(v[i]), vis[v[i]] = 1;
    }
}*/
struct HeapNode {
    int d, u;
    bool operator < (const HeapNode& rhs) const { return d > rhs.d; }
};
inline void SP() {
    priority_queue<HeapNode> Q;
    Set(dis, 127), dis[1] = 0, Set(vis, 0);
    Q.push((HeapNode){0, 1});
    while (!Q.empty()) {
        HeapNode x = Q.top(); Q.pop();
        int u = x.u;
        if (vis[u]) continue;
        vis[u] = 1;
        for (register int i = beg[u]; i; i = nex[i])
            if (chkmin(dis[v[i]], dis[u] + w[i]))
                Q.push((HeapNode){dis[v[i]], v[i]});
    }
}

int find(int tot, int x) { int t = fa.at(tot, x); return t == x ? x : find(tot, t); }

int main()
{
    //File("return");

    for (static int T = read(); T --; ) {
        n = read(), m = read(), Set(beg, 0), e = 0, tot = 0;
        For(i, 1, m) {
            E[i].u = read(), E[i].v = read(), E[i].l = read(), E[i].a = read();
            add(E[i].u, E[i].v, E[i].l), add(E[i].v, E[i].u, E[i].l);
        }

        SP(), sort(E + 1, E + 1 + m);
        Q = read(), K = read(), S = read();
        fa.init(), sz.init(), mn.init();
        For(i, 1, n) fa.push(i, mp(0, i)), sz.push(i, mp(0, 1)), mn.push(i, mp(0, dis[i]));
        For(i, 1, m) {
            register int t = E[i].a;
            ls[++ tot] = t;
            while (i <= m && E[i].a == t) {
                int fu = find(tot, E[i].u), fv = find(tot, E[i].v);
                if (fu != fv) {
                    if (sz.at(tot, fu) > sz.at(tot, fv)) {
                        fa.push(fv, mp(tot, fu));
                        sz.push(fu, mp(tot, sz.at(tot, fu)));
                        mn.push(fu, mp(tot, min(mn.at(tot, fu), mn.at(tot, fv))));
                    } else {
                        fa.push(fu, mp(tot, fv));
                        sz.push(fv, mp(tot, max(sz.at(tot, fv), sz.at(tot, fu) + 1)));
                        mn.push(fv, mp(tot, min(mn.at(tot, fv), mn.at(tot, fu))));
                    }
                }
                ++ i;
            }
            -- i;
        }

        ls[0] = INF, lastans = 0;
        while (Q --) {
            v0 = (read() + K * lastans - 1) % n + 1, p0 = (read() + K * lastans) % (S + 1);
            int l = 0, r = tot, mid;
            while (l < r) {
                mid = (l + r + 1) >> 1;
                if (ls[mid] > p0) l = mid; else r = mid - 1;
            }
            printf("%d\n", lastans = mn.at(l, find(l, v0)));
        }
    }

    return 0;
}
//登高壮观天地间，大江茫茫去不还。
//    -- 李白《庐山谣寄卢侍御虚舟》