「NOIP 2015」运输计划「树链剖分」

这题就没往二分上想，直接使用线段树+树剖大暴力

做法就是枚举每一条边$(u,fa[u],w)$，求出删除这条边后的答案。

假设已经求出了两个数组$past[u],nopast[u]$分别表示经过u的路径长度最大值, 不过u的路径长度最大值

那么删除边$(u,fa[u],w)$后答案就是$max(past[u]-w,nopast[u])$

考虑怎么在树剖时候用两个线段树维护$past,nopast$

加入一条树上路径$(u,v,d)$的时候

$past$很方便更新，树剖的时候区间取$max$一下

$nopast$很需要把past更新的区间记录下来然后排序，记为$[l_1,r_1],[l_2,r_2],...,[l_k,r_k]$

然后在$nopast$的线段树上更新$[1,l_1-1],[r_1+1,l_2-1],...,[r_k+1,n]$ 这些区间

时间复杂度是否过大？

加入路径操作每次更新$past$的$O(\log n)$个区间，$nopast$区间实际上也只有$O(\log n)$个，排序需要$O(\log n\log \log n)$的时间，一次加入路径操作的复杂度只有$O(\log n\log \log n+{\log }^{2}n)$，总复杂度只有$O(n+m(\log n\log \log n+{\log }^{2}n))$

（雾

最后有一个常数优化，即其实不需要枚举每一条边，直接枚举最长路径上的边即可（道理十分简单不再赘述）

下面的代码给出了详细注释.注意细节.

#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;
}