【ybt高效进阶4-5-2】【luogu P1081】开车旅行

开车旅行

题目链接：ybt高效进阶4-5-2 / luogu P1081

题目大意

有一些城市，城市间距离为它们的高度差。
然后要从一个城市一直往右走。
然后两个人小 A 小 B，小 A 选择第二近的城市作为目的地（相同距离选海拔低的），小 B 选择最近的城市作为目的地。
如果无法按意愿选或者要走的距离超过给定值 x，就结束。

然后问你两个问题。
给定 x，要你选一个位置，使得小 A 走的距离与小 B 走的距离的比最小。（如果小 B 距离为 0，则为无穷大）若比值相同就选海拔小的。
或者给出 x 和出发城市，求两人走过距离。

思路

这道题题目看半天看不懂是真的烦。

那我们看懂题目之后想想模拟是怎么样的，就每次先确定是谁开车，然后在从后面枚举找到距离最近或者第二近的，然后就走。

那我们可以考虑处理出从一个城市开始，让 A 走和让 B 走分别可以走到哪里。

那我们可以把高度都排个序，然后用链表的方式做。
具体讲讲怎么做：
大概是每次从这个点的链表左右两边分别扩展，找到距离它最近的那两个。
然后就把这个点从链表中删除，就直接它前面的下一个变成它的下一个，它后面的前一个变成它的前一个。

那你就可以通过这样的方法求出来了。

但是一个一个跳还是很慢。
那我们可以考虑把跳的过程加速，自然想到倍增。
但是问题就是两个人是交替走的。
那你会想到一个方法，就是让 $f_{0/1,i,j}$ 为 $i$ 出发，第一步是 $A/B$ 走，然后按这个顺序走 $2^k$ 步所能到达的地方。
然后因为你要求距离，你还可以开一个 $dis$ 记录距离。

那我们考虑怎么弄，你会想到只有当 $j=1$ 的时候，第一次走和第二次走开始的人是不同的，其它情况下（当然 $j\neq0$，这个情况我们就是前面处理了）两次走开始的人都是同一个。

那你就分开来做一下，就好了。

然后你询问二就直接用倍增的方式跳。
询问一其实就是 $n$ 个询问二，因为询问复杂度是 $O(log n)$，所以可以直接暴力枚举每个询问二，然后找到最优的那个。

代码

#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;
}

__EOF__

本文作者：あおいSakura
本文链接：https://www.cnblogs.com/Sakura-TJH/p/YBT_GXJJ_4-5-2.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！