这题就没往二分上想,直接使用线段树+树剖大暴力
做法就是枚举每一条边 ( u , f a [ u ] , w ) (u, fa[u], w) (u,fa[u],w),求出删除这条边后的答案。
假设已经求出了两个数组 p a s t [ u ] , n o p a s t [ u ] past[u], nopast[u] past[u],nopast[u]分别表示经过u的路径长度最大值, 不过u的路径长度最大值
那么删除边 ( u , f a [ u ] , w ) (u, fa[u], w) (u,fa[u],w)后答案就是 m a x ( p a s t [ u ] − w , n o p a s t [ u ] ) max(past[u] - w, nopast[u]) max(past[u]−w,nopast[u])
考虑怎么在树剖时候用两个线段树维护 p a s t , n o p a s t past, nopast past,nopast
加入一条树上路径 ( u , v , d ) (u, v, d) (u,v,d)的时候
p a s t past past很方便更新,树剖的时候区间取 m a x max max一下
n o p a s t nopast nopast很需要把past更新的区间记录下来然后排序,记为 [ l 1 , r 1 ] , [ l 2 , r 2 ] , . . . , [ l k , r k ] [l_1, r_1],[l_2, r_2],...,[l_k, r_k] [l1,r1],[l2,r2],...,[lk,rk]
然后在 n o p a s t nopast nopast的线段树上更新 [ 1 , l 1 − 1 ] , [ r 1 + 1 , l 2 − 1 ] , . . . , [ r k + 1 , n ] [1, l_1-1], [r_1+1, l_2-1], ..., [r_k + 1, n] [1,l1−1],[r1+1,l2−1],...,[rk+1,n] 这些区间
时间复杂度是否过大?
加入路径操作每次更新 p a s t past past的 O ( log n ) O(\log n) O(logn)个区间, n o p a s t nopast nopast区间实际上也只有 O ( log n ) O(\log n) O(logn)个,排序需要 O ( log n log log n ) O(\log n\log\log n) O(lognloglogn)的时间,一次加入路径操作的复杂度只有 O ( log n log log n + log 2 n ) O(\log n\log\log n+\log^2n) O(lognloglogn+log2n),总复杂度只有 O ( n + m ( log n log log n + log 2 n ) ) O(n+m(\log n\log\log n+\log^2n)) O(n+m(lognloglogn+log2n))
(雾
最后有一个常数优化,即其实不需要枚举每一条边,直接枚举最长路径上的边即可(道理十分简单不再赘述)
下面的代码给出了详细注释.注意细节.
#include <algorithm>
#include <cstdio>
#include <vector>
using namespace std;
typedef long long LL;
const int N = 3e5 + 10;
struct Edge { int v, w; };
vector<Edge> G[N];
int n, m, df[N];
int fa[N], dep[N], son[N], sz[N];
int top[N], idx[N], seg[N], dfn;
LL dep2[N], ans, past[N], nopast[N];
//fa, dep, son, sz, top, idx, seg为树剖内容
//df[u]表示u到fa[u]的距离 ; dep2[u]表示根到u到距离
//past[u]表示经过点u的路径最大值
//nopast[u]表示不过点u的路径最大值
void dfs1(int u, int f) {
sz[u] = 1; dep[u] = dep[fa[u] = f] + 1;
for(int i = 0; i < G[u].size(); i ++) {
int & v = G[u][i].v, & w = G[u][i].w;
if(v ^ f) {
dep2[v] = dep2[u] + (df[v] = w); dfs1(v, u); sz[u] += sz[v];
if(sz[v] > sz[son[u]]) son[u] = v;
}
}
}
void dfs2(int u, int topf) {
top[seg[idx[u] = ++ dfn] = u] = topf;
if(!son[u]) return ;
dfs2(son[u], topf);
for(int i = 0, v; i < G[u].size(); i ++)
if(!idx[v = G[u][i].v]) dfs2(v, v);
}
// 以上为树链剖分板子
struct Seg {
// 线段树维护最大值
LL tag[N << 2] = {0};
void pushd(int k) { //懒标记下传
if(!tag[k]) return ;
tag[k << 1] = max(tag[k << 1], tag[k]);
tag[k << 1 | 1] = max(tag[k << 1 | 1], tag[k]);
tag[k] = 0;
}
void modify(int k, int l, int r, int L, int R, LL w) { //区间修改
if(l > R || r < L) return ;
if(L <= l && r <= R) return void (tag[k] = max(tag[k], w));
if(l == r) return ;
int mid = l + r >> 1; pushd(k);
if(L <= mid) modify(k << 1, l, mid, L, R, w);
if(mid < R) modify(k << 1 | 1, mid + 1, r, L, R, w);
}
LL query(int k, int l, int r, int p) { //单点查询
if(l == r) return tag[k];
int mid = l + r >> 1; pushd(k);
if(p <= mid) return query(k << 1, l, mid, p);
return query(k << 1 | 1, mid + 1, r, p);
}
void getmx(int k, int l, int r, LL * arr) { //获取叶子结点信息
if(l == r) return void (arr[seg[l]] = tag[k]);
int mid = l + r >> 1; pushd(k);
getmx(k << 1, l, mid, arr);
getmx(k << 1 | 1, mid + 1, r, arr);
}
} s1, s2;
// s1维护经过i的路径最大值
// s2维护不过i的路径最大值
LL TreeDis(int u, int v) { //树剖求两点距离
const int uu = u, vv = v;
for(; top[u] ^ top[v]; u = fa[top[u]])
if(dep[top[u]] < dep[top[v]]) u ^= v ^= u ^= v;
if(dep[u] > dep[v]) u ^= v ^= u ^= v;
return dep2[uu] + dep2[vv] - 2ll * dep2[u];
}
void TreeAdd(int u, int v, const LL & d) { //加入一条路径
struct Node {
int l, r;
bool operator < (const Node & node) const { return l < node.l; }
};
static Node pos[N];
int cnt = 0;
for(; top[u] ^ top[v]; u = fa[top[u]]) {
if(dep[top[u]] < dep[top[v]]) u ^= v ^= u ^= v;
s1.modify(1, 1, n, idx[top[u]], idx[u], d);
pos[cnt ++] = Node {idx[top[u]], idx[u]};
}
if(dep[u] > dep[v]) u ^= v ^= u ^= v;
if(idx[u] ^ idx[v]) {
//注意idx[u]要 + 1, lca到fa[lca]到边是不经过的
s1.modify(1, 1, n, idx[u] + 1, idx[v], d);
pos[cnt ++] = Node {idx[u] + 1, idx[v]};
}
sort(pos, pos + cnt); //把覆盖区间排序
//把没有覆盖的区间更新 s2, 注意最左和最右的区间也要更新
if(pos[0].l > 1) s2.modify(1, 1, n, 1, pos[0].l - 1, d);
if(pos[cnt - 1].r < n) s2.modify(1, 1, n, pos[cnt - 1].r + 1, n, d);
for(int i = 0; i < cnt - 1; i ++) {
int ll = pos[i].r + 1, rr = pos[i + 1].l - 1;
if(ll <= rr) s2.modify(1, 1, n, ll, rr, d);
}
}
void TreeForce(int u, int v) { //在树上暴力跳枚举边
int uu = u, vv = v;
for(; top[u] ^ top[v]; u = fa[top[u]])
if(dep[top[u]] < dep[top[v]]) u ^= v ^= u ^= v;
if(dep[u] > dep[v]) u ^= v ^= u ^= v;
for(int i = uu; i ^ u; i = fa[i]) //u -> lca
ans = min(ans, max(past[i] - df[i], nopast[i]));
for(int i = vv; i ^ u; i = fa[i]) //v -> lca
ans = min(ans, max(past[i] - df[i], nopast[i]));
}
int main() {
int u, v, w;
scanf("%d%d", &n, &m);
for(int i = 1; i < n; i ++) {
scanf("%d%d%d", &u, &v, &w);
G[u].push_back(Edge {v, w});
G[v].push_back(Edge {u, w});
}
dfs1(1, 0); dfs2(1, 1);
int su, sv; LL maxd = -1; //记录最长路径
for(int i = 1; i <= m; i ++) {
scanf("%d%d", &u, &v);
LL d = TreeDis(u, v);
TreeAdd(u, v, d);
ans = max(ans, d);
if(d > maxd) maxd = d, su = u, sv = v;
}
s1.getmx(1, 1, n, past); //获取经过i的路径最大值
s2.getmx(1, 1, n, nopast); //获取不过i的路径最大值
TreeForce(su, sv); //在最长路径上枚举边
printf("%lld\n", ans);
return 0;
}