md, 链式前向星, 因为cost是ll, 就写下面了, 都开 [N << 1]了, 就co[N], 硬是自己瞎想,找了2h bug, 哭唧唧

题面

设T=(V, E, W) 是一个无圈且连通的无向图（也称为无根树），每条边带有正整数的权，我们称T为树网（treenetwork），其中V, E分别表示结点与边的集合，W表示各边长度的集合，并设T有n个结点。

路径：树网中任何两结点a,b都存在唯一的一条简单路径，用d(a,b)表示以a,b为端点的路径的长度，它是该路径上各边长度之和。

我们称d(a,b)为a,b两结点间的距离。

一点v到一条路径P的距离为该点与P上的最近的结点的距离：

d(v，P)=min{d(v，u)，u为路径P上的结点}。

树网的直径：树网中最长的路径称为树网的直径。

对于给定的树网T，直径不一定是唯一的，但可以证明：各直径的中点（不一定恰好是某个结点，可能在某条边的内部）是唯一的，我们称该点为树网的中心。

偏心距ECC(F)：树网T中距路径F最远的结点到路径F的距离，即：

ECC(F)=max{d(v,F),v∈V}

任务：对于给定的树网T=(V, E,W)和非负整数s，求一个路径F，它是某直径上的一段路径（该路径两端均为树网中的结点），其长度不超过s（可以等于s），使偏心距ECC(F)最小。

我们称这个路径为树网T=(V,E,W)的核（Core）。

必要时，F可以退化为某个结点。

一般来说，在上述定义下，核不一定只有一个，但最小偏心距是唯一的。

输入格式

包含n行： 第1行，两个正整数n和s，中间用一个空格隔开，其中n为树网结点的个数，s为树网的核的长度的上界，设结点编号依次为1, 2, …, n。

从第2行到第n行，每行给出3个用空格隔开的正整数，依次表示每一条边的两个端点编号和长度。

例如，“2 4 7”表示连接结点2与4的边的长度为7。

所给的数据都是正确的，不必检验。

输出格式

只有一个非负整数，为指定意义下的最小偏心距。

数据范围

n≤500000,s<231

输入样例：

5 2
1 2 5
2 3 2
2 4 4
2 5 3

输出样例：

5

题解

求直径, 回溯之类的就不说了

证明部分

在任意一条直径上求出的最小偏心距都相等

树的直径中点成活, 相当于 任意一条直径 把其他直径切成了 两半

要明白对答案有贡献的时 路径距直径两端的距离 和 路径上分支的最大长度(当直径长度小于等于s时才贡献)

当直径不止一条时, 这偏心距必为直径的一半, 且路径包含直径的中点 (自己画画, 本人画丑就不放图了)

解法一, 枚举 O($n^3$)

枚举就不用说了吧, 两层遍历一层搜索

这个只用于 n <= 300 数据范围的题, 5e5 就别考虑了

解法二,枚举+贪心 O($n^2$)

在直径上尺取法, 枚举少了一层

解法三, 二分 O(nlogSUM)

答案单调, 自然可二分

解法四和五, 线性 O(n)

解法四就是和五差不多, 一个是分类讨论, 一个是单调队列, 线性思路是一样的

上面证明说了 路径上分支的最大长度对答案贡献(当直径长度小于等于s时才贡献)

方法四就是分 直径大于s和 小于等于 s

方法五就时一股脑全考虑直接找到直径上所有最远点(不在直径上的点)的距离,

尺取线性取min

这里直接上法4, 5代码

#include <bits/stdc++.h>
#define all(n) (n).begin(), (n).end()
#define se second
#define fi first
#define pb push_back
#define mp make_pair
#define sqr(n) (n)*(n)
#define rep(i,a,b) for(int i=a;i<=(b);++i)
#define per(i,a,b) for(int i=a;i>=(b);--i)
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
typedef pair<ll, ll> PLL;
typedef vector<int> VI;
typedef double db;

const int N = 5e5 + 5;

int n, m, _, k;
int h[N], ne[N << 1], to[N << 1], tot, f[N];
ll co[N << 1], d[N], b[N], ans = 2e18;
bool v[N];

void add(int u, int v, ll c) {
    ne[++tot] = h[u]; h[u] = tot; to[tot] = v; co[tot] = c;
}

void dfs(int u) {
    v[u] = 1;

    for (int i = h[u]; i; i = ne[i]) {
        int y = to[i];
        if (v[y]) continue;
        d[y] = d[u] + co[i];
        if (d[y] > d[0]) d[0] = d[y], f[0] = y;
        f[y] = u;
        dfs(y);
    }
}

void work(int& p, int& q) {
    memset(v, 0, sizeof v); d[0] = -N;
    d[1] = 0; dfs(1); p = f[0]; f[p] = 0;
    memset(v, 0, sizeof v); d[0] = -N;
    d[p] = 0; dfs(p); q = f[0]; 
}

void dfss(int u, int fa) {
    v[u] = 1;

    for (int i = h[u]; i; i = ne[i]) {
        int y = to[i];
        if (v[y]) continue;

        if (u == fa) d[y] = co[i];
        else d[y] = d[u] + co[i];

        b[fa] = max(d[y], b[fa]);
        dfss(y, fa);
    }
}

int main() {
    ios::sync_with_stdio(0); cin.tie(0);
    cin >> n >> m;
    rep(i, 2, n) {
        int u, v; ll c; cin >> u >> v >> c;
        add(u, v, c); add(v, u, c);
    }

    int p, q; work(p, q); 

    if (d[q] > m) {
        for (int i = q, j = q; i; i = f[i]) {
            while (f[j] && d[i] - d[f[j]] <= m) j = f[j];
            ans = min(ans, max(d[j], d[q] - d[i]));
        }
    }
    else {
        ans = 0;
        memset(v, 0, sizeof v);
        for (int i = q; i; i = f[i]) v[f[i]] = 1, dfss(i, i), ans = max(ans, b[i]);
    }

    cout << ans;
    return 0;
}

你要追求性能, 就把边改成前向星, stl挺慢的

#include <bits/stdc++.h>
#define IOS ios::sync_with_stdio(false);cin.tie(0);cout.tie(0)
using namespace std;

const int  N = 5e5 + 5;

int n, m, _;
int f[N], p, q;
long long d[N], mx, ans = 2e18;
vector<pair<int, int>> h[N];

void dfs(int x, int fa, int& s) {
    for (auto& y : h[x]) if (y.first != fa) {
        d[y.first] = d[x] + y.second; f[y.first] = x;
        if (d[0] < d[y.first]) d[0] = d[s = y.first];
        dfs(y.first, x, s);
    }
}

void work() {
    f[1] = d[1] = 0; dfs(1, 0, p);
    d[0] = f[p] = d[p] = 0; dfs(p, 0, q);
}

void dfs(int x, int fa) {
    for (auto& y : h[x]) if (y.first != fa) {
        mx = max(mx, d[y.first] = d[x] + y.second);
        dfs(y.first, x);
    }
}

int main() {
    IOS; cin >> n >> m;
    for (int i = 1; i < n; ++i) {
        int u, v, c; cin >> u >> v >> c;
        h[u].emplace_back(v, c); h[v].emplace_back(u, c);
    }
    work();
    for (int i = q, j = 0; i; j = i, i = f[i]) for (auto& y : h[i])
        if (y.first != j && y.first != f[i]) mx = max(mx, d[y.first] = y.second), dfs(y.first, i);
    for (int i = q, j = q; i; i = f[i]) {
        while (f[j] && d[i] - d[f[j]] <= m) j = f[j];
        ans = min(ans, max(mx, max(d[j], d[q] - d[i])));
    }
    cout << ans;
    return 0;
}