JZOJ 4289.Mancity

$Mancity$

$Description$

$Input$

$Output$

$Sample Input$

8 3 6
1 2
1 1
3 2
4 2
5 1
6 1
6 2
4 1
3 3
2 4
4 2
2 5
8 2

$Sample Output$

1
0
2
2
3
4

$Hint$

$Data Constraint$

大致理一会题意，发现就是两个点 $u,v$ 每步向上跳 $d$ 距离，每步不能落在边上，在他们的 $lca$ 处转身，经过 $lca$ 直到相遇，求最少步数
而有了这句话，我们就可以直接模拟 $u,v$ 同时一步一步往上跳，跳到离 $lca$ 最近的点（不超过 $lca$），再看这两个点的距离，计算贡献

然而太慢，我们发现一步一步向上跳太 $naive$
又想到倍增就是改一步一步向上跳为一次向上跳 $2^i$步，预处理向上跳 $2^i$ 步是谁
那么我们似乎可以同理维护一步跳距离为 $d$，每步不能落在边上，一次跳 $2^i$ 步是谁
记为 $top[u][i]$，表示 $u$ 向上跳 $2^i$步落在哪个点，只用算 $top[u][0]$ 就可以得到其它的 $top$了。
这样忒慢的一步一步跳变成了 $O(logn)$ 级别的

那么怎么算 $top[u][0]$？
我们如果从 $u$ 处向上一条边一条边地算，那么时间是不可接受的
注意到，$u$ 的 $top[u][0]$ 必然是他的祖先，并且 $top[u][0]$ 必然是 $top[fa[u]][0]$ 或往下
那么我们就可以从 $top[fa[u][0]]$ 处扫，不合法就往下
你向上跳的路径是固定的（你只有一个father），可往下就不一定了
所以我们开一个栈 $stack$，$dfs$ 到当前点 $u$，将它入栈，那么你求 $top[fa[u]][0]$ 往下跳时，必然是 $top[fa[u]][0]$ 在栈中的编号加一（根据 $dfs$ 遍历的顺序可得）
为了方便处理，我们让 $top[u][0]$ 先表示 $top[u][0]$ 在栈中的编号
然后回溯时让 $top[u][0] = stack[top[u][0]]$，即变为具体的点
详细细节见 $Code1$

$Code1$

倍增，$nlogn$，$80$ 分

#include<cstdio>
#include<iostream>
using namespace std;
 
const int N = 5e5 + 5;
int n , d , q , fa[N] , anc[N][25] , f[N][25];
int tot , dep[N] , h[N] , dis[N] , st[N] , top;
 
struct edge{
	int nxt , to;
}e[2 * N];
 
inline void add(int x , int y)
{
	e[++tot].to = y;
	e[tot].nxt = h[x];
	h[x] = tot;
}
 
inline void dfs(int x)
{
	st[++top] = x;
	anc[x][0] = max(1 , anc[fa[x]][0]); //最近跳到根1，anc即上文提及的top，先存栈中的编号
	while (dis[x] - dis[st[anc[x][0]]] > d) anc[x][0]++; //跳不了那么远，换栈中下一个
	
	for(register int i = 1; i <= 21; i++)
	if (f[x][i - 1]) f[x][i] = f[f[x][i - 1]][i - 1];
	else break;
	
	for(register int i = h[x]; i; i = e[i].nxt)
	{
		int v = e[i].to;
		dep[v] = dep[x] + 1 , f[v][0] = x;
		dfs(v);
	}
	
	anc[x][0] = st[anc[x][0]]; //回溯变具体的点
	--top;
}
 
inline int LCA(int x , int y)
{
	if (dep[x] < dep[y]) swap(x , y);
	int deep = dep[x] - dep[y];
	for(register int i = 0; i <= 21; i++)
	if (deep & (1 << i)) x = f[x][i];
	if (x == y) return x;
	for(register int i = 21; i >= 0; i--)
		if (f[x][i] != f[y][i]) x = f[x][i] , y = f[y][i];
	return f[x][0];
}
 
inline int getans(int x , int y)
{
        int lca = LCA(x , y) , res = 0;
        //根据求出来的anc，让u，v同时往上跳
	for(register int i = 21; i >= 0; i--) 
		if (dis[anc[x][i]] > dis[lca]) x = anc[x][i] , res = res + (1 << i);
	for(register int i = 21; i >= 0; i--)
		if (dis[anc[y][i]] > dis[lca]) y = anc[y][i] , res = res + (1 << i);
	if (x == y) return res;
        //处理转弯处需要的步数
	if (dis[x] + dis[y] - 2 * dis[lca] <= d) return res + 1;
	else return res + 2;
}
 
int main()
{
	freopen("mancity.in" , "r" , stdin);
	freopen("mancity.out" , "w" , stdout);
	scanf("%d%d%d" , &n , &d , &q);
	for(register int i = 2; i <= n; i++)
	{
		scanf("%d%d" , &fa[i] , &dis[i]);
		dis[i] += dis[fa[i]];
		add(fa[i] , i);
	}
	dfs(1);
	
	for(register int i = 1; i <= n; i++) 
		for(register int j = 1; j <= 21; j++)
			if (anc[i][j - 1]) anc[i][j] = anc[anc[i][j - 1]][j - 1];
			else break;
	int x , y;
	for(register int i = 1; i <= q; i++)
	{
		scanf("%d%d" , &x , &y);
		printf("%d\n" , getans(x , y));
	}
}

正如你所见 $O(nlogn)$ 竟然过不了
出题人毒瘤卡 $O(nlogn)$ !
那我还要更快？！
可求 $lca$，树剖和倍增都是 $nlogn$ 的呀？？？
咦，题目似乎可以离线！
嗯，那就上 $Tarjan$ 求 $lca$ 吧！
$Tarjan$ 求 $lca$ 大致思想是将询问挂在节点上，遍历到它的时候就去处理询问
按照 $dfs$ 遍历的顺序，我们在遍历完一个节点后将它合并的它的祖先节点
如果当前点为 $u$ ，它的询问对象 $v$ 已经被访问过，那么他们的最近公共祖先就是 $find(v)$
当然，不明白的话就去查查百度

注意，如果 $u,v$ 是祖孙关系，那么处理询问时它们两个都会算
所以存储时要开两倍数组

不过，上面的 $Tarjan$ 求 $lca$ 快很多了，可计算答案怎么搞？
重新记 $top[u]$ 表示原先的 $top[u][0]$
其实，我们注意到 $u$ 所对应的 $top[u]$ 是唯一的，它们不会形成环
于是所有的 $top$ 关系又组成了一棵树
那么求 $u,v$ 最接近公共祖先的两个节点时也可以同 $Tarjan$ 一样使用并查集
我们在遍历完一个节点后将它合并的 $top$ 节点
将询问挂在 $lca$ 处
因为正在处理 $lca$ ，所以查询 $u,v$ 两点各自的 $top$ 树的祖先绝对不会超过 $lca$（$lca$ 还没合并到它的 $top$）
所以我们直接 $find(u),find(v)$，就得到了离 $lca$ 最近的点。当然，求步数时给并查集加个权值就好了
然后转弯时上文同理
详见 $Code2$

$Code2$

$Tarjan$ ， 并查集， $O(n \alpha(n))$，$100$ 分

#include<cstdio>
#include<iostream>
using namespace std;
 
const int N = 5e5 + 5;
int n , d , q , top[N] , stop , stack[N];
int tot1 , tot2 , tot3 , tot4 , h1[N] , h2[N] , h3[N] , h4[N];
int dis[N] , fa[N] , vis[N] , ask[N][3] , ans[N] , dist[N];
 
struct edge{
	int nxt , to;
}e1[N] , e2[N] , e4[2 * N];
 
struct edgeask{
	int nxt , to , id;
}e3[2 * N];
 
inline void add1(int x , int y) //原来的树
{
	e1[++tot1].to = y;
	e1[tot1].nxt = h1[x];
	h1[x] = tot1;
}
 
inline void add2(int x , int y) //Top关系树
{
	e2[++tot2].to = y;
	e2[tot2].nxt = h2[x];
	h2[x] = tot2;
}
 
inline void add3(int x , int y , int z) //ask，Tarjan时用来求一个点和其询问对象的 $lca$
{
	e3[++tot3].to = y;
	e3[tot3].id = z;
	e3[tot3].nxt = h3[x];
	h3[x] = tot3;
}
 
inline void add4(int x , int y) //lca处处理询问，即在询问挂在lca处，遍历到时再处理
{
	e4[++tot4].to = y;
	e4[tot4].nxt = h4[x];
	h4[x] = tot4;
}
 
inline int find1(int x) //tarjan时所用的并查集的find
{
	if (fa[x] == x) return x;
	fa[x] = find1(fa[x]);
	return fa[x];
}
 
inline int find2(int x) //top关系树所用的并查集的find
{
	if (top[x] == x) return x;
	int t = top[x];
	top[x] = find2(top[x]);
	dist[x] += dist[t]; //路压合并时，加上它father的权值
	return top[x];
}
 
inline void dfs1(int u)
{
        //同理计算top
	stack[++stop] = u;
	top[u] = max(1 , top[fa[u]]);
	while (dis[u] - dis[stack[top[u]]] > d) top[u]++;
	
	for(register int i = h1[u]; i; i = e1[i].nxt)
		dfs1(e1[i].to);
		
	top[u] = stack[top[u]]; //更换为具体点
	--stop; 
	add2(top[u] , u);
}
 
inline void dfs2(int u)
{
	top[u] = u , fa[u] = u , vis[u] = 1;
	for(register int i = h1[u]; i; i = e1[i].nxt)
	{
		dfs2(e1[i].to);
		fa[e1[i].to] = u;
	}
	
	for(register int i = h3[u]; i; i = e3[i].nxt) //求lca
	{
		int v = e3[i].to;
		if (!vis[v]) continue;
		add4(find1(v) , e3[i].id);
	}
	
	for(register int i = h4[u]; i; i = e4[i].nxt) //lca处处理询问
	{
		int id = e4[i].to , x = ask[id][0] , y = ask[id][1];
		int xx = x , yy = y;
		x = find2(x) , y = find2(y); //求两个浅点
		int m = dis[x] + dis[y] - dis[u] * 2;
		ans[id] = dist[xx] + dist[yy] + (m > 0) + (m > d);
	}
	
	for(register int i = h2[u]; i; i = e2[i].nxt) top[e2[i].to] = u , dist[e2[i].to] = 1; //维护top
}
 
int main()
{
	freopen("mancity.in" , "r" , stdin);
	freopen("mancity.out" , "w" , stdout);
	scanf("%d%d%d" , &n , &d , &q);
	for(register int i = 2; i <= n; i++) 
	{
		scanf("%d%d" , &fa[i] , &dis[i]);
		dis[i] += dis[fa[i]];
		add1(fa[i] , i);
	}
	dfs1(1);
	
	for(register int i = 1; i <= q; i++) 
	{
		scanf("%d%d" , &ask[i][0] , &ask[i][1]);
		add3(ask[i][0] , ask[i][1] , i) , add3(ask[i][1] , ask[i][0] , i); //将询问挂上去
	}
	dfs2(1);
	for(register int i = 1; i <= q; i++) printf("%d\n" , ans[i]);
}