开车旅行
题目链接：ybt高效进阶4-5-2 / luogu P1081
题目大意
有一些城市，城市间距离为它们的高度差。
然后要从一个城市一直往右走。
然后两个人小 A 小 B，小 A 选择第二近的城市作为目的地（相同距离选海拔低的），小 B 选择最近的城市作为目的地。
如果无法按意愿选或者要走的距离超过给定值 x，就结束。
然后问你两个问题。
给定 x，要你选一个位置，使得小 A 走的距离与小 B 走的距离的比最小。（如果小 B 距离为 0，则为无穷大）若比值相同就选海拔小的。
或者给出 x 和出发城市，求两人走过距离。
思路
这道题题目看半天看不懂是真的烦。
那我们看懂题目之后想想模拟是怎么样的，就每次先确定是谁开车，然后在从后面枚举找到距离最近或者第二近的，然后就走。
那我们可以考虑处理出从一个城市开始，让 A 走和让 B 走分别可以走到哪里。
那我们可以把高度都排个序，然后用链表的方式做。
具体讲讲怎么做：
大概是每次从这个点的链表左右两边分别扩展，找到距离它最近的那两个。
然后就把这个点从链表中删除，就直接它前面的下一个变成它的下一个，它后面的前一个变成它的前一个。
那你就可以通过这样的方法求出来了。
但是一个一个跳还是很慢。
那我们可以考虑把跳的过程加速，自然想到倍增。
但是问题就是两个人是交替走的。
那你会想到一个方法，就是让 f 0 / 1 , i , j f_{0/1,i,j} f0/1,i,j 为 i i i 出发，第一步是 A / B A/B A/B 走，然后按这个顺序走 2 k 2^k 2k 步所能到达的地方。
然后因为你要求距离，你还可以开一个 d i s dis dis 记录距离。
那我们考虑怎么弄，你会想到只有当 j = 1 j=1 j=1 的时候，第一次走和第二次走开始的人是不同的，其它情况下（当然 j ≠ 0 j\neq0 j=0，这个情况我们就是前面处理了）两次走开始的人都是同一个。
那你就分开来做一下，就好了。
然后你询问二就直接用倍增的方式跳。
询问一其实就是 n n n 个询问二，因为询问复杂度是 O ( l o g n ) O(log n) O(logn)，所以可以直接暴力枚举每个询问二，然后找到最优的那个。
代码
#include<cstdio>
#include<algorithm>
#define ll long long
using namespace std;
struct node {
int x, num;
}h[100001];
int n, pl[100001], pre[100001], nxt[100001];
int f[2][100001][21], m, ans, st;
ll dis[2][100001][21], a, b, x;
double minn;
int abss(int x) {
if (x < 0) return -x;
return x;
}
bool cmp(node x, node y) {
return x.x < y.x;
}
bool compare(int j, int l, int r) {
//比较哪边优
if (!l) return 0;
if (!r) return 1;
return h[j].x - h[l].x <= h[r].x - h[j].x;
}
int get_sec(int j, int l, int r) {
//再比较出第二优的
if (!l) return h[r].num;
if (!r) return h[l].num;
if (h[j].x - h[l].x <= h[r].x - h[j].x) return h[l].num;
return h[r].num;
}
void get_zero() {
//走一步（2^0）
for (int i = 1; i <= n; i++)
pl[h[i].num] = i, pre[i] = i - 1, nxt[i] = i + 1;
pre[1] = nxt[n] = 0;
for (int i = 1; i <= n; i++) {
int j = pl[i];
int l = pre[j];
int r = nxt[j];
if (compare(j, l, r)) f[1][i][0] = h[l].num, f[0][i][0] = get_sec(j, pre[l], r);
else f[1][i][0] = h[r].num, f[0][i][0] = get_sec(j, l, nxt[r]);
if (l) nxt[l] = r;
if (r) pre[r] = l;
}
}
void get_one() {
//走两步（2^1）因为这一步要先A开始一步B开始一步，跟后面两个都是A开始走不一样，所以也要特殊弄
for (int i = 1; i <= n; i++) {
f[0][i][1] = f[1][f[0][i][0]][0];
dis[0][i][1] = abss(h[pl[i]].x - h[pl[f[0][i][0]]].x);
dis[1][i][1] = abss(h[pl[f[0][i][1]]].x - h[pl[f[0][i][0]]].x);
}
}
void get_all() {
//正常A开始走两次，倍增
for (int j = 2; j <= 19; j++)
for (int i = 1; i <= n; i++) {
f[0][i][j] = f[0][f[0][i][j - 1]][j - 1];
dis[0][i][j] = dis[0][i][j - 1] + dis[0][f[0][i][j - 1]][j - 1];
dis[1][i][j] = dis[1][i][j - 1] + dis[1][f[0][i][j - 1]][j - 1];
}
}
void get_ab(ll x, int st) {
//根据倍增看能走到哪里，然后算贡献
a = 0;
b = 0;
for (int i = 19; i >= 1; i--)
if (f[0][st][i] && a + b + dis[0][st][i] + dis[1][st][i] <= x) {
a += dis[0][st][i];
b += dis[1][st][i];
st = f[0][st][i];
}
if (f[0][st][0] && a + b + dis[0][st][1] <= x) a += dis[0][st][1];
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &h[i].x), h[i].num = i;
sort(h + 1, h + n + 1, cmp);
get_zero();
get_one();
get_all();
scanf("%lld %d", &x, &m);
minn = 2147483647;
for (int i = 1; i <= n; i++) {
//直接暴力算出每个，然后比较出最优的
get_ab(x, i);
if (b && 1.0 * a / b < minn) {
minn = 1.0 * a / b;
ans = i;
}
}
printf("%d\n", ans);
while (m--) {
scanf("%d %lld", &st, &x);
get_ab(x, st);//直接算
printf("%lld %lld\n", a, b);
}
return 0;
}