【洛谷】1081：开车旅行【倍增】【双向链表】

P1081 开车旅行

题目描述

小A 和小B 决定利用假期外出旅行，他们将想去的城市从 1到 N 编号，且编号较小的城市在编号较大的城市的西边，已知各个城市的海拔高度互不相同，记城市 i的海拔高度为Hi​，城市 i和城市j之间的距离 d[​i,j]恰好是这两个城市海拔高度之差的绝对值，即d[​i,j]=∣Hi​−Hj​∣。

旅行过程中，小 A和小 B 轮流开车，第一天小 A 开车，之后每天轮换一次。他们计划选择一个城市 S 作为起点，一直向东行驶，并且最多行驶X 公里就结束旅行。小A 和小 B的驾驶风格不同，小 B总是沿着前进方向选择一个最近的城市作为目的地，而小A总是沿着前进方向选择第二近的城市作为目的地（注意：本题中如果当前城市到两个城市的距离相同，则认为离海拔低的那个城市更近）。如果其中任何一人无法按照自己的原则选择目的城市，或者到达目的地会使行驶的总距离超出 XX 公里，他们就会结束旅行。

在启程之前，小 A想知道两个问题：

1. 对于一个给定的 X=X0​，从哪一个城市出发，小A 开车行驶的路程总数与小B 行驶的路程总数的比值最小（如果小 B 的行驶路程为0，此时的比值可视为无穷大，且两个无穷大视为相等）。如果从多个城市出发，小A 开车行驶的路程总数与小 B行驶的路程总数的比值都最小，则输出海拔最高的那个城市。
2. 对任意给定的X=Xi​和出发城市Si​，小 A 开车行驶的路程总数以及小 B行驶的路程总数。

输入输出格式

输入格式：

 

第一行包含一个整数 N，表示城市的数目。

第二行有 N个整数，每两个整数之间用一个空格隔开，依次表示城市 1 到城市N的海拔高度，即 H1​,H2​,…,Hn​，且每个 Hi​都是不同的。

第三行包含一个整数X0​。

第四行为一个整数 M，表示给定 M组 Si​和Xi​。

接下来的 M 行，每行包含 2个整数 Si​和 Xi​，表示从城市Si​出发，最多行驶 Xi​公里。

 

输出格式：

 

输出共M+1行。

第一行包含一个整数 S0​，表示对于给定的 X0​，从编号为 S0​ 的城市出发，小 A开车行驶的路程总数与小B 行驶的路程总数的比值最小。

接下来的 M行，每行包含2个整数，之间用一个空格隔开，依次表示在给定的 Si​和Xi​下小 A 行驶的里程总数和小 B 行驶的里程总数。

输入输出样例

输入样例#1： 复制

4 
2 3 1 4 
3 
4 
1 3 
2 3 
3 3 
4 3

输出样例#1： 复制

1 
1 1 
2 0 
0 0 
0 0 

输入样例#2： 复制

10 
4 5 6 1 2 3 7 8 9 10 
7 
10 
1 7 
2 7 
3 7 
4 7 
5 7 
6 7 
7 7 
8 7 
9 7 
10 7

输出样例#2： 复制

2 
3 2 
2 4 
2 1 
2 4 
5 1 
5 1 
2 1 
2 0 
0 0 
0 0

说明

【输入输出样例1说明】

各个城市的海拔高度以及两个城市间的距离如上图所示。

如果从城市 1 出发，可以到达的城市为 2,3,4，这几个城市与城市 1 的距离分别为 1,1,2，但是由于城市 3 的海拔高度低于城市 2，所以我们认为城市 3 离城市 1 最近，城市 2 离城市 1 第二近，所以小A会走到城市2。到达城市2后，前面可以到达的城市为3,4，这两个城市与城市2的距离分别为2,1，所以城市4离城市2最近，因此小B会走到城市4。到达城市4后，前面已没有可到达的城市，所以旅行结束。

如果从城市 2 出发，可以到达的城市为 3,4，这两个城市与城市2的距离分别为 2,1，由于城市 3 离城市 2 第二近，所以小A会走到城市3。到达城市3后，前面尚未旅行的城市为4，所以城市4离城市3最近，但是如果要到达城市4，则总路程为 2+3=5>3，所以小B会直接在城市3结束旅行。

如果从城市 3 出发，可以到达的城市为 4，由于没有离城市3第二近的城市，因此旅行还未开始就结束了。

如果从城市 4 出发，没有可以到达的城市，因此旅行还未开始就结束了。

【输入输出样例2说明】

当 X=7 时，如果从城市 1 出发，则路线为1→2→3→8→9，小A走的距离为1+2=3，小B走的距离为1+1=2。（在城市1时，距离小A最近的城市是2和6，但是城市2的海拔更高，视为与城市1第二近的城市，所以小A最终选择城市2；走到9后，小A只有城市10可以走，没有第2选择可以选，所以没法做出选择，结束旅行）

如果从城市2出发，则路线为2→6→7，小A和小B走的距离分别为2,4。

如果从城市3出发，则路线为3→8→9，小A和小B走的距离分别为2,1。

如果从城市4出发，则路线为4→6→7，小A和小B走的距离分别为2,4。

如果从城市5出发，则路线为5→7→8，小A和小B走的距离分别为5,1。

如果从城市6出发，则路线为6→8→9，小A和小B走的距离分别为5,1。

如果从城市7出发，则路线为7→9→10，小A和小B走的距离分别为2,1。

如果从城市8出发，则路线为8→10，小A和小B走的距离分别为2,0。

如果从城市9出发，则路线为9，小A和小B走的距离分别为0,0（旅行一开始就结束了）。

如果从城市10出发，则路线为10，小A和小B走的距离分别为0,0。

从城市2或者城市4出发小A行驶的路程总数与小B行驶的路程总数的比值都最小，但是城市2的海拔更高，所以输出第一行为2。

【数据范围与约定】

对于30%的数据，有1≤N≤20,1≤M≤20；
对于40%的数据，有1≤N≤100,1≤M≤100；
对于50%的数据，有1≤N≤100,1≤M≤1,000；
对于70%的数据，有1≤N≤1,000,1≤M≤10,000；
对于100%的数据，有1≤N≤100,000,1≤M≤100,000, −109≤Hi​≤109, 0≤X0​≤109, 1≤Si​≤N,0≤X−i≤109，数据保证Hi​互不相同。

---

在思维和码力上都很好的一道题了。

所以索自己代码还是写少了啊！！就算知道怎么做也写挂了QAQ

首先，可以知道题目中从每个位置开始走，$A$和$B$走到的点是固定的，走的路线和路程也是唯一确定的。而我们要做的就是快速找到从某一个位置开始，快速找到走距离满足条件能到达的路径。

想到倍增。可是$A$和$B$是交换往前走的，如何定义倍增数组也是一个巧妙的地方。因为所有都是从$A$先开始走，所以定义$fa[i][j]$和$fb[i][j]$分别表示$A$和$B$从$i$点开始走$2^j$轮走过的路程和。所谓轮，就是$A$走一次，$B$再走一次。

再定义$g[i][j]$表示从$i$点开始走$2^j$轮到达的位置。转移显然。（这都是预处理的部分）

预处理中最麻烦但是最重要的是处理出每个位置到达的下一个位置。（一开始就写得乱七八糟不清晰aaa！！）排序后，用双向链表将相邻三个连接起来（我连的是原序列的下标），扫一遍原序列下标，处理完一个后把它删去（才学了的链表删除操作！！）

主要是判断排序后头和尾的问题。头和尾的左右会少，对判断造成了混乱...看了dalao写的简直不要太清晰aaa！！把每一个小操作理清楚过后写一个小函数就干净多了。

然后要跳$x$的距离的话，就从起点开始，把$j$（即$2^j$）从大往小扫，能跳就跳，一定可以表示完（最后一步判一下$A$可不可以再跳）【倍增的基本原理！】然后整个过程就结束了~

#include<bits/stdc++.h>
#define LL long long
using namespace std;

int n;

struct CI {
    LL h;
    int id;
} city[100005];
bool cmp(CI a, CI b) { return a.h < b.h; }

int pre[100005], nex[100005];

LL fa[100005][21], fb[100005][21], la[100005], lb[100005];
int g[100005][21], juma[100005], jumb[100005];
void query(int s, int x, LL &a, LL &b) {
    for(int i = 20; i >= 0; i --)
        if(fa[s][i] + fb[s][i] <= x && g[s][i]) {
            a += fa[s][i];
            b += fb[s][i];
            x -= fa[s][i] + fb[s][i];
            s = g[s][i];
        }
    if(juma[s] && fa[s][0] <= x)    a += fa[s][0];
}

LL Abs(LL x) {
    if(x > 0)    return x;
    return -x;
}

LL h[100005];
bool check(int id) {
    if(!pre[id])    return 0;
    if(!nex[id])    return 1;
    return h[id] - h[pre[id]] <= h[nex[id]] - h[id];
}

int pd(int id, int a, int b) {
    if(!a)    return b;
    if(!b)    return a;
    if(h[id] - h[a] <= h[b] - h[id])    return a;
    return b;
}

int main() {
    scanf("%d", &n);
    for(int i = 1; i <= n; i ++)    scanf("%lld", &h[i]), city[i].h = h[i], city[i].id = i;
    sort(city + 1, city + 1 + n, cmp);
    
    pre[city[1].id] = nex[city[n].id] = 0;
    for(int i = 1; i < n; i ++)
        pre[city[i].id] = city[i-1].id, nex[city[i].id] = city[i+1].id;
    pre[city[1].id] = nex[city[n].id] = 0;
    pre[city[n].id] = city[n-1].id;
    
    for(int i = 1; i <= n; i ++) {
        if(check(i))    jumb[i] = pre[i], juma[i] = pd(i, pre[pre[i]], nex[i]);
        else jumb[i] = nex[i], juma[i] = pd(i, pre[i], nex[nex[i]]);
        if(pre[i])    nex[pre[i]] = nex[i];
        if(nex[i])    pre[nex[i]] = pre[i];
    }
    
    for(int i = 1; i <= n; i ++)
        la[i] = Abs(h[juma[i]] - h[i]), lb[i] = Abs(h[jumb[i]] - h[i]);
    for(int i = 1; i <= n; i ++) {
        g[i][0] = jumb[juma[i]];
        fa[i][0] = la[i];
        fb[i][0] = lb[juma[i]];
    }
    for(int p = 1; p <= 20; p ++)
        for(int i = 1; i <= n; i ++) {
            g[i][p] = g[g[i][p-1]][p-1];
            fa[i][p] = fa[i][p-1] + fa[g[i][p-1]][p-1];
            fb[i][p] = fb[i][p-1] + fb[g[i][p-1]][p-1];
        }
        
    int x0, s0 = 0;
    LL na = 1e15, nb = 0;
    scanf("%d", &x0);
    for(int i = 1; i <= n; i ++) {
        LL a = 0, b = 0;
        query(i, x0, a, b);
        if(b && (!s0 || (na * b > nb * a))) {
            s0 = i;    na = a;    nb = b;
        }
    }
    printf("%d\n", s0);
    
    int m;
    scanf("%d", &m);
    for(int i = 1; i <= m; i ++) {
        int s, x;
        LL a = 0, b = 0;
        scanf("%d%d", &s, &x);
        query(s, x, a, b);
        printf("%lld %lld\n", a, b);
    }
    return 0;
}