【洛谷5465】[PKUSC2018] 星际穿越（倍增）

点此看题面

大致题意： 给定\(l_{2\sim n}\)，其中\(l_i\)表示\([l_i,i-1]\)的所有点与\(i\)之间存在一条长度为\(1\)的双向路径。每次询问给出\(l,r,x\)，求\(\frac 1{r-l+1}\sum_{y=l}^{r}dist(x,y)\)。

重要性质

首先我们需要知道，这道题关键在于如何求出任意两点间的距离。

一个简单的性质，从\(i\)出发，如果你能通过\(t\)步到达\(x\)，则必然能到达满足\(x\le y\le i\)的任意\(y\)。

而现在我们来考虑一个重要的问题，即：从点\(i\)出发，经过一步，能到达哪些点？

首先，\([l_i,i-1]\)显然是能够到达的。

然后呢？再仔细去研究一下，便会发现题目中提到路径是双向的，所以对于那些\(l_x\le i\)且\(x>i\)的\(x\)，也是能够到达的。

那么，从点\(i\)出发，经过两步，能到达的编号最小的点是什么呢？

这自然就是所有\(i\)经过一步能到达的点所能一步到达的编号最小的点中编号最小的了，即：

\[\min_{k=l_i}^nl_k
\]

注意，之所以这里枚举的范围可以是\(l_i\sim n\)，是因为这一范围中除去符合条件（即能够一步到达）的点以外都是\(l_x>i\)的点，这些点自然无法对答案造成贡献，因此枚举在内并无影响。

继续下去，从点\(i\)出发，经过三步，能到达的编号最小的点是什么呢？

很显然，如果设经过\(x\)步能到达的编号最小的点为\(p_x\)，那么：

\[p_3=\min_{k=p_2}^nl_k
\]

推广可知：

\[p_x=\min_{k=p_{x-1}}^nl_k
\]

然后我们就可以发现，除去第一步能到达的点比较特殊以外，其余时候能到达的点都有一定规律。

实际上，在已确定当前能到达的编号最小的点的情况下，下一步能到达的编号最小的点是唯一确定的。

于是乎，我们就能想到倍增。

倍增

首先我们特殊处理第一步，因为它比较特殊。

接下来，我们设\(f_{x,y}\)表示\(x\)再走\(2^y\)步所能到达的编号最小的点，并用\(g_{x,y}\)表示\([f_{x,y},x-1]\)范围内所有点到\(x\)的距离之和。

\(f\)的预处理，显然就是传统的\(f_{x,y}=f_{f_{x,y-1},y-1}\)，而\(g\)的预处理就要略显复杂。

首先，\([f_{x,y-1},x-1]\)到\(x\)的路径总和\(g_{x,y-1}\)与\([f_{x,y},f_{x,y-1}-1]\)到\(f_{x,y-1}\)的路径总和\(g_{f_{x,y-1},y-1}\)显然都是要计算在内的。

而\([f_{x,y},f_{x,y-1}-1]\)内的点从\(f_{x,y-1}\)到\(x\)的距离都要另行计算，而这一距离实际上就是\(2^{y-1}\)。

又因为要计算这一距离的点共有\(f_{x,y-1}-f_{x,y}\)个，所以\(g_{x,y}=g_{x,y-1}+g_{f_{x,y-1},y-1}+(f_{x,y-1}-f_{x,y})\times 2^{y-1}\)。

如果定义一个函数\(Jump(x,y)\)，其值为\([y,x-1]\)范围内所有点到\(x\)的距离之和，则有：

\[\sum_{y=l}^{r}dist(x,y)=Jump_(x,l)-Jump(x,r+1)
\]

也就是说，实现\(Jump(x,y)\)之后，我们就可以差分计算出答案了。

而\(Jump(x,y)\)的实现，就可以利用上面的倍增数组。

先特殊处理第一步，初始化答案为\(x-l_x\)（实际上就是\(1\times(x-l_x)\)）。然后更新\(x\)为\(l_x\)（因为这一部分的答案已经计算过了），并初始化\(k=1\)（表示接下来所有点到初始\(x\)的距离都需要加上\(1\)），接下来从大到小枚举\(i\)表示前进\(2^i\)步。

对于\([f_{x,i},x-1]\)到现在\(x\)的距离，就是\(g_{x,i}\)，而其到初始\(x\)的距离还要加上\(k\)，由于共有\(x-f_{x,i}\)个点，因此也就是加上\(k(x-f_{x,i})\)。然后我们更新\(x\)为\(f_{x,i}\)，并将\(k\)加上\(2^i\)。

重复此流程，即可。

注意最后还要求一次剩余点到\(x\)的距离，因为并不是所有点都恰好是\(f\)的，以保证处理完毕。

具体实现详见代码。

代码

#include<bits/stdc++.h>
#define Tp template<typename Ty>
#define Ts template<typename Ty,typename... Ar>
#define Reg register
#define RI Reg int
#define Con const
#define CI Con int&
#define I inline
#define W while
#define N 300000
#define LN 20
#define LL long long
using namespace std;
int n,a[N+5],f[N+5][LN+5];LL g[N+5][LN+5];
class FastIO
{
	private:
		#define FS 100000
		#define tc() (A==B&&(B=(A=FI)+fread(FI,1,FS,stdin),A==B)?EOF:*A++)
		#define pc(c) (C==E&&(clear(),0),*C++=c)
		#define tn (x<<3)+(x<<1)
		#define D isdigit(c=tc())
		int T;char c,*A,*B,*C,*E,FI[FS],FO[FS],S[FS];
	public:
		I FastIO() {A=B=FI,C=FO,E=FO+FS;}
		Tp I void read(Ty& x) {x=0;W(!D);W(x=tn+(c&15),D);}
		Tp I void write(Ty x) {W(S[++T]=x%10+48,x/=10);W(T) pc(S[T--]);}
		Tp I void write(Con Ty& x,Con char& y) {write(x),pc(y);}
		I void clear() {fwrite(FO,1,C-FO,stdout),C=FO;}
}F;
I LL Jump(RI x,CI y)//倍增求答案
{
	if(y>=a[x]) return x-y;LL t=x-a[x],k=1;x=a[x];//特殊处理第一步
	for(RI i=LN;~i;--i) y<=f[x][i]&&(t+=k*(x-f[x][i])+g[x][i],k+=1<<i,x=f[x][i]);//重复执行中间过程
	return t+=k*(x-y)+(x-y);//最后保证处理完毕
}
I LL gcd(Con LL& x,Con LL& y) {return y?gcd(y,x%y):x;}//求最大公约数，用于约分
int main()
{
	RI Qt,i,j,x,y,z;LL t,d;for(F.read(n),i=2;i<=n;++i) F.read(a[i]);//读入数据
	for(f[n][0]=a[n],g[n][0]=n-a[n],i=n-1;i;--i) f[i][0]=min(a[i],f[i+1][0]),g[i][0]=i-f[i][0];//初始化f和g
	for(j=1;j<=LN;++j) for(i=1;i<=n;++i) f[i][j]=f[f[i][j-1]][j-1],//倍增打表f
		g[i][j]=g[i][j-1]+g[f[i][j-1]][j-1]+((1LL*f[i][j-1]-f[i][j])<<j-1);//倍增打表g
	F.read(Qt);W(Qt--) F.read(x),F.read(y),F.read(z),//处理询问
		t=Jump(z,x)-Jump(z,y+1),d=gcd(t,y-x+1),F.write(t/d,'/'),F.write((y-x+1)/d,'\n');//差分
	return F.clear(),0;
}