「PKUSC2018 星际穿越」Solution

题目传送门

[PKUSC2018] 星际穿越

简述题意

给定一张 $n$ 个点的无向图和 $q$ 次询问，每一个点 $i$ 与 $\forall j\in [l_i,i-1]$ 都存在一条长度为 $1$ 的无向边，每次询问给定 $l_i,r_i,x_i$，求 $\frac{1}{r_i-l_i+1}{\sum }_{y=l_i}^{r_i}dist(x_i,y)$ 的最简分数形式。

• $n,q\le 3\times 10^5，1\le l_i<r_i<x_i\le n$

思路

Subtask1 & 2

直接把图建出来，对每一个点暴力跑一遍 $\text{dijkstra}$，每次询问累和即可。
时间复杂度 $O(n^{2}logn)$，可以得到 $45pts$。

Subtask3

与正解强相关！

先把图降维成序列问题，把 $n$ 个点抽象成 $n$ 个元素的序列 $a$。

考虑贪心，由于 $l_i<r_i<x_i$，因此一定尽可能往右跳，才能最小化步数。
不妨令 $nx{t}_{i,j}$ 表示从 $i$ 开始跳 $j$ 步，能到达的最小点。

显然 $nx{t}_{i,0}=l_i$，然而 $nx{t}_{i,1}$ 一定等于 $l_{l_{x_i}}$ 嘛？

不是。如果有一个点 $j\in [l_{x_i},i-1]$ 满足 $l_j\le l_{l_{x_i}}$，那么跳到 $j$ 一定比跳到 $l_{x_i}$ 更优，因此有：

n x t i , j = min ⁡ { l n x t i , j − 1 , . . . , l i − 1 , l i , l i + 1 , . . . , l n } nxt_{i,j}=\min\{l_{nxt_{i,j-1}},...,l_{i-1},l_i,l_{i+1},...,l_n\} nxti,j​=min{lnxti,j−1​​,...,li−1​,li​,li+1​,...,ln​}

为什么要考虑 $[i+1,n]$ 这一部分呢？因为有可能往右跳比往左跳更优，举个例子可能更形象：

假如 $5$ 是起点，$1$ 是终点，那么很显然 $5\to 6$ 比 $5\to 4$ 更优。

因此枚举每个点作为起点，进行一次上述过程即可。
最坏时间复杂度 $O(n^2)$，可以得到 $75pts$。

Subtask4

上述做法中，发现我们的时间复杂度瓶颈在于 $j$ 这一维，而且正解时间复杂度应该是 $O(nlogn)$，这都启发我们倍增。

不妨令 $d{p}_{i,j}$ 表示从 $i$ 开始跳 $2^j$ 步能够到达的最小点。

那么有经典倍增式 $d{p}_{i,j}=d{p}_{d{p}_{i,j-1},j-1}$。

然后显然有 $d{p}_{i,0}=l_i$？大多数人的第一想法可能都是这样初始化，然而这显然是错的！
再举个例子。

如上图，如果这样初始化就有 $d{p}_{5,1}=d{p}_{d{p}_{5,0},0}=d{p}_{3,0}=2$，然而显然可以 $5\to 4\to 1$，为什么会出错呢？由 $\text{subtask3}$ 的做法可得，我们没有考虑往右跳的情况。

然而每个点都会出现往右跳的情况吗？
显然不是。具体地，有如下引理：

引理：
在任意最优情形下，只有起点可能往右跳，其他点一定只会向左跳。
证明也是显然的，如果当前点往右跳到 $x$ 更优，那为何不直接从上一个点（一定会有前驱点）跳到 $x$ 呢？

因此，我们只需要考虑起点往右跳的情况，就可以保证递推的重要性，因此 d p i , 0 = min ⁡ { l i , l i + 1 , . . . , l n } dp_{i,0}=\min\{l_i,l_{i+1},...,l_n\} dpi,0​=min{li​,li+1​,...,ln​}（至于那些 $i$ 往右跳无法到达的点一定有 $l_j>i$，所以考虑了也无所谓），发现这样初始化代入上述例子也是对的。

考虑如何回答询问。不妨令 $su{m}_{i,j}$ 表示 $i$ 到 $[d{p}_{i,j},i-1]$ 的距离和，注意 $sum$ 并未包含向右跳的贡献，这一部分要在后面单独讨论！！！

那么有 $su{m}_{i,0}=i-d{p}_{i,0}$。

• 先考虑 $[d{p}_{i,j-1},i-1]$ 这一部分的贡献，即 $su{m}_{i,j-1}$。
• 再考虑 $[d{p}_{i,j},d{p}_{i,j-1}-1]$ 这一部分的贡献，我们已知从 $d{p}_{i,j-1}$ 这个点走到这些点的距离，即为 $su{m}_{d{p}_{i,j-1},j-1}$，所以只需要从 $i$ 走 $2^{j-1}$ 到 $d{p}_{i,j-1}$，一共要走 $d{p}_{i,j-1}-d{p}_{i,j}$ 次。

总结一下有：
$$su{m}_{i,j}=su{m}_{i,j-1}+su{m}_{d{p}_{i,j-1},j-1}+2^{j-1}\times (d{p}_{i,j-1}-d{p}_{i,j})$$

注意，在上述推导过程中，我们并未考虑从起点往右跳的贡献，这一部分会在后文详细阐述。

求得 $dp,sum$ 以后，即可处理询问：

该函数旨在求出求出 $x$ 走到 $[lpos,x-1]$ 的距离和。

有注释的部分应该很好理解，瓶颈在于框出的两行代码，网上大多数题解这一部分都没有写明白。

为什么要强制走到 $l_x$ 呢？注意到，我们之前 $sum$ 的推导并没有考虑 $x$ 最开始往右跳的贡献，所以我们要强制选择一个点，那么为什么选择了 $l_i$ 呢？

• 如果 $x$ 最开始向右跳到 $y$ 更优，那么从 $l_x$ 出发可以且一定会跳到 $y$，就等价于 $x$ 跳到 $y$，区别在于 $l_x$ 出发可以顺便处理这一部分的贡献。
• 如果 $x$ 最开始向左跳到 $x$ 更优，同理，从 $l_x$ 出发也一定会跳到 $y$。

通俗的讲，先强制选择 $l_x$ 其作用就在于等着被替代成其他点。表面上从 $x$ 跳到了 $l_x$，实际是从 $x$ 跳到了 $y$。
即 $x\to l_x\to y$ 等价于 $x\to y$，但前者可以处理向右跳的贡献。

结合样例可以更好理解。

如果 $6$ 为起点，那么我们会强制跳到 $4$，表面上错过了可以直达 $1$ 的 $5$，但是 $4$ 是可以且一定会向右跳到 $5$ 的，因为我们的倍增是最优的。

代码

一道非常好的倍增题！！！

#include <bits/stdc++.h>
#define int long long
using namespace std;
const int MAXN = 3e5 + 5;
int n , q , dp[MAXN][20] , sum[MAXN][20] , l[MAXN];
int solve(int x , int lpos) { // 求出 x 走到 [lpos , x-1] 的距离和
	if (l[x] <= lpos) return x - lpos; // 特判一步走到的情况
	int ans = x - l[x] , step = 1;
	x = l[x];
	for (int i = 19 ; i >= 0 ; i --) { 
		if (dp[x][i] >= lpos) {// 只要还未到达终点，就不断往前倍增跳
			ans += (x - dp[x][i]) * step + sum[x][i]; // 和 sum 的推导类似
			x = dp[x][i] , step += (1 << i); // step 表示当前走过的步数
		}
	}
	step ++;
	if (x > lpos) ans += (x - lpos) * step; // 处理不能恰好到达 x 的情况
	return ans;	
}
signed main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr) , cout.tie(nullptr);
	cin >> n;
	for (int i = 2 ; i <= n ; i ++) cin >> l[i] , dp[i][0] = l[i];
	for (int i = n - 1 ; i >= 2 ; i --) dp[i][0] = min(dp[i + 1][0] , dp[i][0]);
	for (int i = 1 ; i <= n ; i ++) sum[i][0] = i - dp[i][0];
	for (int j = 1 ; j <= 19 ; j ++) {
		for (int i = 2 ; i <= n ; i ++) {
			dp[i][j] = dp[dp[i][j - 1]][j - 1];
			sum[i][j] = sum[i][j - 1] + sum[dp[i][j - 1]][j - 1] + (dp[i][j - 1] - dp[i][j]) * (1 << j - 1);
		}
	}
	cin >> q;
	while(q --) {
		int ql , qr , x;
		cin >> ql >> qr >> x;
		int div = (qr - ql + 1) , w = solve(x , ql) - solve(x , qr + 1);
		int g = __gcd(div , w);
		w /= g , div /= g; // 约分
		cout << w << '/' << div << '\n';
	}
    return 0;
}