题解：CF2057E1&E2 Another Exercise on Graphs

CF2057E1

CF2057E2

Description

• 给定 \(n\) 个点 \(m\) 条边的无向连通带权图，\(q\) 组询问，每次求 \((a, b)\) 两点之间的某条路径的第 \(k\) 大边权最小。

• \(n \le 400\)，\(q \le 3 \times 10^5\)，无重边自环。

• E1：\(n-1 \le m \le \min(400, \frac{n(n-1)}{2})\)

• E2：\(n-1 \le m \le \frac{n(n-1)}{2}\)。

Solution of E1

• 对于询问 \((a, b, k)\)，若存在一个答案 小于等于 某一个值 \(x\)，那么要满足什么条件呢：

  • 如果我们把大于 \(x\) 的边权变成 \(1\)，把小于等于 \(x\) 的边权变成 \(0\)，那么在这个新图中，\((a, b)\) 之间的最短路必须小于 \(k\)。

• 把求值问题转换成了判断问题后，就可以将边权从小到大排序，然后二分答案了。为什么可以二分答案：

  • \(k\) 不变，当 \(x\) 增大时，边权为 \(0\) 的边不降，\((a, b)\) 的最短路也不降，于是当 \(x\) 可行，那么 \(y > x\) 也可行，答案具有单调性，可以二分答案。

• 接下来的问题就是，如何快速判断。

  • 先将边权升序排序。

  • 设 \(f_{i, u, v}\) 表示将 \(1\) 到 \(i\) 的边全部变成 \(0\) 后，\((u, v)\) 间的最短路。

  • 首先 floyd 预处理 \(f_{0}\)，

  • 然后假设当前删掉的边是 \((a, b)\)，那么 \(f_{i, u, v} = \min(f_{i-1, u, v}, f_{i-1, u, a} + f_{i-1, b, v}, f_{i-1, u, b} + f_{i-1, a, v})\)。

  • 转移总复杂度 \(O(n^2m)\)。

Solution of E2

• \(m\) 的范围变大了，普通转移肯定不行。

• 但是我们发现，如果在转移的时候，当前变 \(0\) 的边是 \((a, b)\)，然后 \((a, b)\) 的最短路已经是 \(0\) 了，那么这条边不会更新任何的最短路。

• 对于这种边我们就可以直接跳过，于是用并查集维护即可。

• 同时这种边不用计入 DP 状态里，所以状态数是 \(O(n^3)\)，时间复杂度 \(O(n^3)\)。

Code

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;

const int N = 4e2 + 5, inf = 1e9;

int n, m, q;
vector<vector<vector<int>>> dis;
vector<int> val;

struct Edge { int u, v, w; };
vector<Edge> e;

struct DSU {
    int n;
    vector<int> f, siz;
    DSU(int _n = 0) {
        n = _n;
        f.assign(n + 1, 0);
        siz.assign(n + 1, 1);
        for (int i = 1; i <= n; i++) f[i] = i;
    }
    void init(int _n) {
        n = _n;
        f.assign(n + 1, 0);
        siz.assign(n + 1, 1);
        for (int i = 1; i <= n; i++) f[i] = i;
    }
    int find(int x) {
        return (f[x] == x ? x : f[x] = find(f[x])); // 路径压缩
    }
    bool merge(int x, int y) {
        int fx = find(x), fy = find(y);
        if (fx == fy) return false;
        siz[fy] += siz[fx];
        f[fx] = fy;
        return true;
    }
};
DSU dsu;

void Solve() {
    cin >> n >> m >> q;
    dis.assign(n + 1, vector<vector<int>>(n + 1, vector<int>(n + 1, inf)));
    e.assign(m + 1, {0, 0, 0});
    for (int i = 1; i <= n; i++) {
        dis[0][i][i] = 0;
    }
    for (int i = 1; i <= m; i++) {
        cin >> e[i].u >> e[i].v >> e[i].w;
        dis[0][e[i].u][e[i].v] = dis[0][e[i].v][e[i].u] = 1;
    }
    for (int k = 1; k <= n; k++) {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                dis[0][i][j] = min(dis[0][i][j], dis[0][i][k] + dis[0][k][j]);
            }
        }
    }
    sort(e.begin() + 1, e.end(), [&] (Edge a, Edge b) { return a.w < b.w; });
    val.assign(n + 1, 0);
    int cnt = 0;
    dsu.init(n);
    for (int i = 1; i <= m; i++) {
        int u = e[i].u, v = e[i].v;
        if (!dsu.merge(u, v)) continue;
        val[++cnt] = e[i].w;
        for (int a = 1; a <= n; a++) {
            for (int b = 1; b <= n; b++) {
                dis[cnt][a][b] = min({dis[cnt - 1][a][b], dis[cnt - 1][a][u] + dis[cnt - 1][v][b], dis[cnt - 1][a][v] + dis[cnt - 1][u][b]});
            }
        }
    }
    int a, b, k;
    while (q--) {
        cin >> a >> b >> k;
        int l = 0, r = n - 1, mid;
        while (l < r) {
            mid = l + r >> 1;
            if (dis[mid][a][b] < k) r = mid;
            else l = mid + 1;
        }
        cout << val[r] << ' ';
    }
    cout << '\n';
}

int main() {
    int T;
    cin >> T;
    while (T--) Solve();
    return 0;
}