[CodeChef]Children Trips

题目

传送门 to CodeChef

传送门 to VJ

题意概要
给定带边权树 $T$ 。定义 $a$ 到 $b$ 的 “旅行” 为，最初位置在 $a$，每次选择 $c\in \text{Path}(a,b)$ 使得 $\text{dis}(a,c)⩽z$ 并最大化之，然后移动到 $c$ ；移动到 $b$ 时结束。

共 $q$ 个询问，每次给定 $a,b,z$，请求出 $a$ 到 $b$ 的 “旅行” 所需的移动次数。

数据范围与约定
$\max (n,q)⩽10^5$ 。边权 $\in [1,2]$ 。移动距离限制 $z\in [2,2n]$ 。时限 $8\mathrm{s}$ 。

思路

第一步转化就很关键。至少我在看论文前还没往那个方面想。

显然每一步尽量走长，等价于用最少的步数。可是这样在 $lca$ 那里拐弯之后，就会得到一个奇怪的问题，即自顶向下走。这是很麻烦的一件事，因为 儿子往往比父亲难找到。

仔细想想，$a$ 走到 $b$ 和 $b$ 走到 $a$ 是等价的。那么从 $b$ 出发尽量走长，从 $a$ 出发也尽量走长，最后 在中间相遇，也是可以的！问题终于被规约到了从底往上走。

考虑树上问题的传统算法，比如倍增、树链剖分等，都面临一个问题：如果对不同的 $z$ 都存储结果，根本存不下；如果只是笼统地存距离等，则区间信息无法合并。也就是说，不同的 $z$ 信息不互通。因此，我们应考虑更暴力的方法。

分块正解

由于边权十分特殊，我们会发现如下特性：

• 路径长度最大 $2n$ 。
• 每一次至少会走 $(z-1)$ 的长度。
• 进而有 $z>\sqrt{n}$ 时，最多走 $\mathcal{O}(\sqrt{n})$ 次。

同时，第一点让我们可以离线 $\mathcal{O}(1)$ 处理树上 $z$ 级祖先（走长度为 $z$ 的路径）的询问——自顶向下 $\mathrm{d}\mathrm{f}\mathrm{s}$，维护映射 $f(depth)=x$ ；查询 $f(depth-z)$ 或 $f(depth-z+1)$ 即可。

于是，对于 $z>\sqrt{n}$，我们就用上面这种方法，暴力跳祖先——在 $\mathrm{d}\mathrm{f}\mathrm{s}$ 时先递归子树，使得标记被 “上传”，然后继续往上跳跃就好了。每个询问均摊 $\mathcal{O}(\sqrt{n})$ 。

而 $z⩽\sqrt{n}$ 只有 $\mathcal{O}(\sqrt{n})$ 种，不妨把每一种的显式树（好像更可能是森林）建出来，即每个点下一步会走到哪里。运用上面的 “离线” 做法，每种 $z$ 可以 $\mathcal{O}(n)$ 建树。

在显式树上，只需要找到 $x$ 恰好比 $lca$ 深的祖先。方案很多，比如倍增或树剖，或者 $\mathrm{d}\mathrm{f}\mathrm{s}$ 时维护 $f(depth)=x$ 然后二分查找。时间复杂度 $\mathcal{O}[(n+q)\sqrt{n}+q\log n]$ 。

在线询问

如果询问在线呢？对于 $z>\sqrt{n}$ 的情况，需要在线的 $k$ 级祖先，只需要 $\mathcal{O}(n\log n)-\mathcal{O}(1)$ 的 “长链剖分 $+$ 倍增” 在线方法。对于 $z⩽\sqrt{n}$，需要定位 $lca$ 的位置，可以树链剖分，在最后一条链上二分。时间复杂度不变。

当然，也可以树上分块——实际上是设置关键点，用关键点将树上路径给割开。有两种方案：贪心地递归选取关键点，若子树内某个深度 $⩾\sqrt{n}$ 的点到当前点路径上没有关键点，则设置该点为关键点；或者，选取子树 $⩾\sqrt{n}$ 的、深度为 $\sqrt{n}$ 的倍数的点。

可以证明点数不超过 $\mathcal{O}(\sqrt{n})$，且每个点的祖先中最近的关键点的距离为 $\mathcal{O}(\sqrt{n})$ 。对于每个 $z⩽\sqrt{n}$，预处理每个点到祖先（不含自己）中最近关键点的信息。显然跳 $\mathcal{O}(\sqrt{n})$ 次就能走到 $lca$ 了。

但这样会带来 $\mathcal{O}(n\sqrt{n})$ 的空间开销，不太现实。所以也只是提一提。

代码

注意：在 $lca$ 一步可达时，就要停止。因为此时走到 $lca$ 就不一定能够充分利用移动距离限制了。

#include <cstdio> // megalomaniac JZM yydJUNK!!!
#include <iostream> // Almighty XJX yyds!!!
#include <algorithm> // decent XYX yydLONELY!!!
#include <cstring> // Pet DDG yydOLDGOD!!!
#include <cctype> // oracle: ZXY yydBUSlut!!!
#include <vector>
typedef long long llong;
# define rep(i,a,b) for(int i=(a); i<=(b); ++i)
# define drep(i,a,b) for(int i=(a); i>=(b); --i)
# define rep0(i,a,b) for(int i=(a); i!=(b); ++i)
inline int readint(){
	int a = 0, c = getchar(), f = 1;
	for(; !isdigit(c); c=getchar()) if(c == '-') f = -f;
	for(; isdigit(c); c=getchar()) a = a*10+(c^48);
	return a*f;
}

const int MAXN = 100005;
struct Edge { int to, nxt, val; };
Edge e[MAXN<<1]; int head[MAXN], cntEdge;
inline void addEdge(int a, int b, int c){
	e[cntEdge] = Edge{b,head[a],c}, head[a] = cntEdge ++;
}
# define _go(i,x) for(int i=head[x]; ~i; i=e[i].nxt)

int dep[MAXN], siz[MAXN], son[MAXN], fa[MAXN];
void scan(int x, int pre){
	siz[x] = 1, son[x] = 0;
	_go(i,x) if((i^1) != pre){
		dep[e[i].to] = dep[x]+e[i].val, fa[e[i].to] = x;
		scan(e[i].to,i), siz[x] += siz[e[i].to];
		if(siz[e[i].to] > siz[son[x]]) son[x] = e[i].to;
	}
}
int top[MAXN];
void chainSplit(int x, int bel){
	top[x] = bel; if(son[x]) chainSplit(son[x],bel);
	_go(i,x) if(e[i].to != fa[x] && e[i].to != son[x])
		chainSplit(e[i].to,e[i].to);
}
int getLca(int a, int b){
	while(top[a] != top[b])
		if(dep[top[a]] < dep[top[b]]) b = fa[top[b]];
		else a = fa[top[a]]; // deeper one go up
	return dep[a] < dep[b] ? a : b;
}

struct Query{ int a, b, z, lca, ans; };
Query xw[MAXN]; ///< inquiries

int dep_to_node[MAXN<<1];
std::vector<int> ask[MAXN];
void dfs_big(int x, int pre){
	dep_to_node[dep[x]] = x;
	_go(i,x) if((i^1) != pre) dfs_big(e[i].to,i);
	for(const int &id : ask[x]){
		if(dep[xw[id].lca] > dep[x]-xw[id].z) continue;
		int nxt = dep_to_node[dep[x]-xw[id].z];
		if(!nxt) nxt = dep_to_node[dep[x]-xw[id].z+1];
		(xw[id].a == x ? xw[id].a : xw[id].b) = nxt;
		ask[nxt].push_back(id), ++ xw[id].ans;
	}
	ask[x].clear(), dep_to_node[dep[x]] = 0;
}

std::vector<int> gra[MAXN];
void build_small(const int &z, int x, int pre){
	dep_to_node[dep[x]] = x;
	if(dep[x] > z){ // find father first
		int nxt = dep_to_node[dep[x]-z];
		if(!nxt) nxt = dep_to_node[dep[x]-z+1];
		gra[nxt].push_back(x);
	}
	_go(i,x) if((i^1) != pre) build_small(z,e[i].to,i);
	dep_to_node[dep[x]] = 0; // clear is needed
}
typedef std::pair<int,int> PII;
std::vector<PII> sta; ///< first = dep, second = id
void dfs_small(const int &x){
	sta.push_back(PII{dep[x],x});
	for(const int &id : ask[x]){
		if(xw[id].lca == x) continue; // here it is
		int nxt = int(std::lower_bound(sta.begin(),
			sta.end(),PII{dep[xw[id].lca]+1,0})-sta.begin());
		xw[id].ans += int(sta.size())-nxt-1;
		(xw[id].a == x ? xw[id].a : xw[id].b) = sta[nxt].second;
	}
	for(const int &ch : gra[x]) dfs_small(ch);
	gra[x].clear(), ask[x].clear(), sta.pop_back();
	dep_to_node[dep[x]] = 0;
}

const int SQRTN = 316;
int main(){
	int n = readint();
	memset(head+1,-1,n<<2);
	for(int i=1,a,b,c; i!=n; ++i){
		a = readint(), b = readint(), c = readint();
		addEdge(a,b,c), addEdge(b,a,c);
	}
	dep[1] = 1, scan(1,-1), chainSplit(1,0);
	int q = readint();
	rep(i,1,q){
		xw[i].a = readint(), xw[i].b = readint(), xw[i].z = readint();
		xw[i].lca = getLca(xw[i].a,xw[i].b);
		if(xw[i].z > SQRTN){
			ask[xw[i].a].push_back(i);
			ask[xw[i].b].push_back(i);
		}
	}
	dfs_big(1,-1); // solve all
	rep(z,2,SQRTN){
		rep(i,1,q) if(xw[i].z == z){
			ask[xw[i].a].push_back(i);
			ask[xw[i].b].push_back(i);
		}
		build_small(z,1,-1);
		rep(i,1,n) if(dep[i] <= z) dfs_small(i);
	}
	rep(i,1,q){
		int lst = dep[xw[i].a]+dep[xw[i].b]
			-(dep[xw[i].lca]<<1); // remains
		if(xw[i].z < lst) xw[i].ans += 2;
		else if(lst) ++ xw[i].ans;
		printf("%d\n",xw[i].ans);
	}
	return 0;
}