[NOI2018] 归程 题解

题目描述

[NOI2018] 归程

思路

题目说，所有海拔 $\le p$ 的边都会有积水，因此所有的边分为了两个集合 $S_{\mathrm{车}},S_{\mathrm{步}}$，其中 $S_{\mathrm{车}}$ 所有的边的海拔都 $>p$，$S_{\mathrm{步}}$ 反之。

那么我们要求的 $v$ 到 $1$ 的最短路就可以转换为 $S_{\mathrm{车}}$ 中所有点到 $1$ 的最小值。

如何快速求 $S_{\mathrm{车}}$ 呢？可以考虑 $\text{Kruskal}$ 重构树。

对于一棵重构树上的虚点，它所有子节点都可以在经过不超过虚点点权的边的情况下互相到达。

利用这个性质，把所有的边按降序排序并创建 $\text{Kruskal}$ 重构树。

这样对于虚点 $u$ 使得它的点权（海拔） $u_{al}>p$，那么只要它的子节点中有 $v$ 那么它的其余子节点都可以通过开车到达，为了使能到达的节点数量尽可能的多，在满足 $u_{al}>p$ 的条件下，还要使它的深度 $u_{depth}$ 最小，意味着 $u_{al}>p$ 并且 $u$ 的父亲 $p{a}_{al}\le p$，这样节点 $u$ 的子节点组成的集合就代表着 $S_{\mathrm{车}}$ 了。

如何求得这个 $u$ 呢？从 $v$ 一步步往上爬不可取，可以树上倍增解决。

令 $f[j][i]$ 表示从 $j$ 节点出发向上跳 $2^i$ 步后到达的节点，转移方程为：$f[j][i]=f[f[j][i-1]][i-1]$，$2^{i-1}+2^{i-1}=2^i$。

知道 $S_{\mathrm{车}}$ 的下一步便是求 $S_{\mathrm{车}}$ 中所有点到 $1$ 的最小值。

这一步可以在预处理树上倍增数组的时候顺便维护，定义一个数组 $low[]$ 表示这个节点所有子节点到 $1$ 距离的最小值，转移方程为：$low[i]=min(low[i],low[son])$，其中 $son$ 表示 $i$ 的儿子。

至此问题解决，整理思路：

1. 跑一遍 $\text{Dijkstra}$ 得到所有点到 $1$ 的最小距离；
2. 构建 $\text{Kruskal}$ 重构树；
3. $\text{Dfs}$ 预处理树上倍增数组 $f$ 和子节点到 $1$ 距离最小值数组 $low$；
4. 二进制枚举找到节点 $u$，并输出 $low[u]$，记录 $lastans$ 并多测清空。

时间复杂度：$O(T(m\log n+m\log m+n\log n+Q\log n))$。

代码实现

// Problem: P4768 [NOI2018] 归程
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P4768
// Memory Limit: 512 MB
// Time Limit: 4000 ms
// Author: Moyou
// Copyright (c) 2022 Moyou All rights reserved.
// Date: 2023-01-02 00:16:28

#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#define x first
#define y second
using namespace std;
typedef pair<int, int> PII;

const int N = 2e5 + 10, M = 8e5 + 10;

int lastans, n, m, Q, K, mp;       // mp对应题目中S
int pcnt,                          // 虚点数量
    pval[(N << 1)],                // 虚点的值（海拔）
    low[(N << 1)];                 // 虚点的所有子节点中到1的最小距离
int h[(N << 1)], ne[M], e[M], idx; // 链式前向星存储Kruskal重构树
void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

vector<PII> g[N]; // vector存储用于跑最短路的图

struct qwq // 一条边
{
    int u, v, d, al;
};

int read() // 快读省略

int fa[(N << 1)];
qwq edge[M];
void init() // 初始工作
{
    lastans = 0;
    n = read(), m = read();
    memset(h, -1, sizeof h);
    memset(low, 0x3f, sizeof low);
    idx = 0;
    pcnt = n;
    for (int i = 1; i <= (n << 1); i++)
        g[i].clear();
    for (int i = 1; i <= m; i++)
    {
        int a = read(), b = read(), c = read(), d = read();
        edge[i] = {a, b, c, d};
        g[a].push_back({b, c});
        g[b].push_back({a, c});
    }
    Q = read(), K = read(), mp = read();
    for (int i = 1; i <= n; i++)
        fa[i] = i;
}

int dist[N];
bool st[N];
void dijkstra(int s)
{
    memset(dist, 0x3f, sizeof dist);
    memset(st, 0, sizeof st);
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    heap.push({0, s});
    dist[s] = 0;
    while (heap.size())
    {
        auto t = heap.top().y;
        heap.pop();
        if (st[t])
            continue;
        st[t] = 1;
        for (auto i : g[t])
        {
            int j = i.x, w = i.y;
            if (dist[j] > dist[t] + w)
            {
                dist[j] = dist[t] + w;
                heap.push({dist[j], j});
            }
        }
    }
    for (int i = 1; i <= n; i++)
        low[i] = dist[i];
}

int find(int x)
{
    return fa[x] == x ? x : fa[x] = find(fa[x]);
}

void kruskal() // 构建 Kruskal 重构树
{
    sort(edge + 1, edge + m + 1, [](qwq a, qwq b) { return a.al > b.al; }); // 海拔降序排序
    for (int i = 1; i <= m; i++)
    {
        int x = find(edge[i].u), y = find(edge[i].v);
        if (x == y)
            continue;
        fa[x] = fa[y] = fa[++pcnt] = pcnt;
        pval[pcnt] = edge[i].al; // 点权为海拔
        add(pcnt, x), add(pcnt, y);
    }
}

int f[(N << 1)][23];
void lcadfs(int p, int pa) // 用于预处理的dfs
{
    f[p][0] = pa; // 2^0 = 1，向上跳一步即为自己的父亲
    for (int i = 1; i <= 20; i++) // 转移树上倍增
        f[p][i] = f[f[p][i - 1]][i - 1];
    for (int i = h[p]; ~i; i = ne[i])
    {
        int j = e[i];
        if(j == pa) continue;
        lcadfs(j, p); // 向下遍历子节点
        low[p] = min(low[p], low[j]); // 更新low[]数组（塔尖幻视）
    }
}

int get_ans(int v, int p)
{
    for (int i = 20; i >= 0; i--)
        if (f[v][i] && pval[f[v][i]] > p) // f[v][i] == 0 时代表跳出去了，在 pval[f[v][i]] > p 的情况下没跳出去的情况下尽可能地往上跳 
            v = f[v][i];

    return low[v]; // 输出最终答案
}

void output()
{
    while (Q--)
    {
        int v0 = read(), p0 = read();
        v0 = (v0 + K * lastans - 1) % n + 1;
        p0 = (p0 + K * lastans) % (mp + 1); // 题目要求的在线处理

        printf("%d\n", lastans = get_ans(v0, p0));
    }
}

void work()
{
    init(); // 十年OI一场空，多测不清_____
    dijkstra(1);
    kruskal();
    lcadfs(pcnt, 0);
    output();
}

int main()
{
    int T = read();
    while (T--)
    {
        work();
    }
    return 0;
}