洛谷 P2680 [NOIP2015 提高组] 运输计划

最暴力的做法，没有之一。

记树上结点 \(u\) 到 \(v\) 的简单路径为 \(u \to v\)。

设 \((S, T)\) 为耗时最长的运输计划的起点和终点，其耗时为 \(t\)，则变为虫洞的边必定在 \(S \to T\) 上。

若变为虫洞的边不在 \(S \to T\) 上，则完成阶段性工作的耗时始终是 \(t\)，只有变为虫洞的边在 \(S \to T\) 上，才能使得最后的答案 \(< t\)。

考虑应如何求出每条路径的边权和：将每条边的权值放到其深度较大的端点上，然后树上差分即可。注意不能算 \(lca\) 上的点权，即 \(dis(u, v) = sum_u + sum _v - 2sum_{lca}\)，而不是常见的 \(sum_u + sum_v - sum_{lca} - sum_{flca}\)。

接下来考虑答案的统计。

\[ans = \min_{i \in u \to v \and i \ne v}\{\max\{t - w_i, s_i\}\} \]

其中 \(w_i\) 为下放后 \(i\) 点的点权，\(s_i\) 为不经过 \(i\) 点所代表的边的耗时最长的运输计划的耗时。

可以将树重链剖分后套一个最大值线段树来维护 \(s\)。

对于一段路径 \(u \to v\)，其上的结点在 dfs 序中必定是多段连续的区间，此时用 \(dis(u, v)\) 更新这些区间的并集与 \([1, n]\) 的补集即可。

时间复杂度 \(O(n \log^2 n)\)。

因为是边权下放点权，会带来很多需要注意的细节，具体看又臭又长的代码：

#include <bits/stdc++.h>

#define MAXN 300100
#define lson pos << 1
#define rson pos << 1 | 1

using namespace std;

int n, m, w[MAXN], sum[MAXN];
int tot, head[MAXN];
int dfn, fa[MAXN], dep[MAXN], sz[MAXN], wson[MAXN], idx[MAXN], top[MAXN];
int cnt, maxs;

struct Edge {
    int to, nxt, val;
} e[MAXN << 1];

struct Seg {
    int s, lazy;
} t[MAXN << 2];

struct Node {
    int from, to;

    bool operator<(const Node &rhs) const {
        return from < rhs.from;
    }
} r[20]; // 用于统计不修改的区间

template<typename _T>
void read(_T &_x) {
    _x = 0;
    _T _f = 1;
    char _ch = getchar();
    while (_ch < '0' || '9' < _ch) {
        if (_ch == '-') _f = -1;
        _ch = getchar();
    }
    while ('0' <= _ch && _ch <= '9') {
        _x = (_x << 3) + (_x << 1) + (_ch & 15);
        _ch = getchar();
    }
    _x *= _f;
}

template<typename _T>
void write(_T _x) {
    if (_x < 0) {
        putchar('-');
        _x = -_x;
    }
    if (_x > 9) write(_x / 10);
    putchar('0' + _x % 10);
}

void add(int u, int v, int w) {
    e[++tot] = Edge{v, head[u], w};
    head[u] = tot;
}

void dfs1(int u) {
    sz[u] = 1;
    for (int i = head[u], v; i; i = e[i].nxt) {
        v = e[i].to;
        if (v == fa[u]) continue;
        fa[v] = u, dep[v] = dep[u] + 1;
        w[v] = e[i].val, sum[v] = sum[u] + w[v];
        // dfs 时会形成一棵树，此时 v 就是深度较大的端点，直接下放边权即可
        dfs1(v);
        sz[u] += sz[v];
        if (sz[v] > sz[wson[u]]) wson[u] = v;
    }
}

void dfs2(int u, int tp) {
    idx[u] = ++dfn, top[u] = tp;
    if (wson[u]) dfs2(wson[u], tp);
    for (int i = head[u], v; i; i = e[i].nxt) {
        v = e[i].to;
        if (v == wson[u] || v == fa[u]) continue;
        dfs2(v, v);
    }
}

void pushdown(int pos) {
    if (!t[pos].lazy) return;
    t[lson].s = max(t[lson].s, t[pos].lazy);
    t[lson].lazy = max(t[lson].lazy, t[pos].lazy);
    t[rson].s = max(t[rson].s, t[pos].lazy);
    t[rson].lazy = max(t[rson].lazy, t[pos].lazy);
    t[pos].lazy = 0;
}

void upd(int pos, int l, int r, int x, int y, int &c) {
    if (x <= l && r <= y) {
        t[pos].s = max(t[pos].s, c);
        t[pos].lazy = max(t[pos].lazy, c);
        return;
    }
    pushdown(pos);
    int mid = (l + r) >> 1;
    if (x <= mid) upd(lson, l, mid, x, y, c);
    if (y > mid) upd(rson, mid + 1, r, x, y, c);
    t[pos].s = max(t[lson].s, t[rson].s);
}

int query(int pos, int l, int r, int x) {
    if (l == r) return t[pos].s;
    pushdown(pos);
    int mid = (l + r) >> 1;
    if (x <= mid) return query(lson, l, mid, x);
    return query(rson, mid + 1, r, x);
}

void updroute(int u, int v, int c) {
    cnt = 0;
    while (top[u] != top[v]) {
        if (dep[top[u]] < dep[top[v]]) swap(u, v);
        r[++cnt] = Node{idx[top[u]], idx[u]}; // 记录不需要修改的区间
        u = fa[top[u]];
    }
    if (dep[u] < dep[v]) swap(u, v);
    r[++cnt] = Node{idx[v] + 1, idx[u]};
    // 注意一定是 idx[v] + 1，因为 u -> v 不会经过 (fa[v], v) 这条边。
    sort(r + 1, r + cnt + 1); // 按 dfs 序排序
    if (r[1].from > 1) upd(1, 1, n, 1, r[1].from - 1, c);
    for (int i = 2; i <= cnt; i++) {
        if (r[i - 1].to + 1 > r[i].from - 1) continue; // 防止 upd 死循环
        upd(1, 1, n, r[i - 1].to + 1, r[i].from - 1, c);
    }
    if (r[cnt].to < n) upd(1, 1, n, r[cnt].to + 1, n, c);
}

int LCA(int u, int v) {
    while (top[u] != top[v]) {
        if (dep[top[u]] < dep[top[v]]) swap(u, v);
        u = fa[top[u]];
    }
    return dep[u] < dep[v] ? u : v;
}

int dis(int u, int v) {
    int lca = LCA(u, v);
    return sum[u] - sum[lca] + sum[v] - sum[lca]; // 特殊的树上差分
}

int getans(int u, int v) {
    int lca = LCA(u, v), ans = 2e9;
    while (u != lca) {
        ans = min(ans, max(maxs - w[u], query(1, 1, n, idx[u])));
        u = fa[u];
    }
    while (v != lca) {
        ans = min(ans, max(maxs - w[v], query(1, 1, n, idx[v])));
        v = fa[v];
    }
    // 不统计 lca 处的答案，因为 u -> v 不会经过 (fa[lca], lca) 这条边
    return ans;
}

int main() {
    read(n), read(m);
    for (int i = 1, u, v, w; i < n; i++) {
        read(u), read(v), read(w);
        add(u, v, w), add(v, u, w);
    }
    dfs1(1), dfs2(1, 1);
    int x = 0, y = 0;
    for (int i = 1, u, v; i <= m; i++) {
        read(u), read(v);
        updroute(u, v, dis(u, v));
        if (dis(u, v) > maxs) maxs = dis(u, v), x = u, y = v;
    }
    if (x == y) putchar('0');
    else write(getans(x, y));
    return 0;
}