Acwing 293.开车旅行 （倍增优化DP）

题目

小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总是沿着前进方向选择第二近的城市作为目的地（注意：本题中如果当前城市到两个城市的距离相同，则认为离海拔低的那个城市更近）。

如果其中任何一人无法按照自己的原则选择目的城市，或者到达目的地会使行驶的总距离超出X公里，他们就会结束旅行。

在启程之前，小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≤N≤105,
1≤M≤104,
−109≤Hi≤109,
0≤X0≤109,
1≤Si≤N,
0≤Xi≤109，
数据保证Hi互不相同。

输入样例：
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
3 2
2 4
2 1
2 4
5 1
5 1
2 1
2 0
0 0
0 0

思路

好难的题目，qwq，首先我们如果选定了一个城市作为起点，那么我们接下来的ab行程将是唯一确定的，因为题目限制四了条件，相当于是一个拓扑图了，这个信息我们可以预处理出来。然后我们还需要处理出从某个人从某个点开始走多少步数到达的城市，这里我们就需要倍增优化了，因为数据是1e5，暴力枚举n方会超时。然后我们最后要处理的就是最后的dp数组，表示某个人从某个点出发走i步数，所行驶的所有距离。

代码实现

#include<cstdio>
#include<algorithm>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<iostream>
#include<cstring>
#include<cmath>
using namespace std;
#define rep(i,f_start,f_end) for (int i=f_start;i<=f_end;++i)
#define per(i,n,a) for (int i=n;i>=a;i--)
#define MT(x,i) memset(x,i,sizeof(x) )
#define rev(i,start,end) for (int i=start;i<end;i++)
#define inf 0x3f3f3f3f
#define mp(x,y) make_pair(x,y)
#define lowbit(x) (x&-x)
#define MOD 1000000007
#define exp 1e-8
#define N 1000005 
#define fi first 
#define se second
#define pb push_back
typedef long long ll;
typedef pair<int ,int> PII;
ll gcd (ll a,ll b) {return b?gcd (b,a%b):a; }
inline int read() {
    char ch=getchar(); int x=0, f=1;
    while(ch<'0'||ch>'9') {
        if(ch=='-') f = -1;
        ch=getchar();
    } 
    while('0'<=ch&&ch<='9') {
        x=x*10+ch-'0';
        ch=getchar();
    }   return x*f;
}

typedef pair<ll,int> PLT;
const int maxn=100010,M=17;
const ll INF=1e12;
int n;
int h[maxn];
int ga[maxn],gb[maxn];
int f[M][maxn][2];
int da[M][maxn][2],db[M][maxn][2];

void init_g () {
    set <PLT> s;
    s.insert ({INF,0}),s.insert ({INF+1,0});
    s.insert ({-INF,0}),s.insert ({-INF-1,0});

    per (i,n,1) {
        PLT t(h[i],i);
        auto j=s.lower_bound (t);
        j++;
        vector <PLT > cand;
        rev (k,0,4) {
            cand.pb (*j);
            j--;
        }
        ll d1=INF,d2=INF;
        int p1=0,p2=0;
        per (k,3,0) {
            ll d= abs (h[i]-cand[k].first);
            if (d<d1) {
                d2=d1,d1=d;
                p2=p1,p1=cand[k].second;
            }
            else if (d<d2){
               d2=d;
               p2=cand[k].second;
            }
        }
        ga[i]=p2,gb[i]=p1;
        s.insert (t);
    }
}


void init_f () {
   rev (i,0,M) 
    rep (j,1,n) {
        if (!i) f[0][j][0]=ga[j],f[0][j][1]=gb[j];
        else {
            rev (k,0,2) {
                if (i==1) f[1][j][k]=f[0][f[0][j][k]][1-k];
                else f[i][j][k]=f[i-1][f[i-1][j][k]][k];
            }
        }
    }
}

inline int get_dis (int a,int b) {
   return abs (h[a]-h[b]);
}

void init_d () {
    rev (i,0,M) 
     rep (j,1,n) {
         if (!i) {
            da[0][j][0]=get_dis (j,ga[j]),da[0][j][1]=0;
            db[0][j][1]=get_dis (j,gb[j]),db[0][j][0]=0;
         }
         else {
             rev (k,0,2) {
                 if (i==1) {
                    da[1][j][k]=da[0][j][k]+da[0][f[0][j][k]][1-k];
                    db[1][j][k]=db[0][j][k]+db[0][f[0][j][k]][1-k];
                 }
                 else {
                     da[i][j][k]=da[i-1][j][k]+da[i-1][f[i-1][j][k]][k];
                     db[i][j][k]=db[i-1][j][k]+db[i-1][f[i-1][j][k]][k];
                 }
             }
         }

     }
}

void solve (int p,int x,int &la,int &lb) {
    la=0,lb=0;
    per (i,M-1,0) {
        if (f[i][p][0]&&la+lb+da[i][p][0]+db[i][p][0]<=x) {
            la+=da[i][p][0],lb+=db[i][p][0];
            p=f[i][p][0];
        } 
    }
} 

int main () {
   cin>>n;
   rep (i,1,n) cin>>h[i];
   init_g ();
   init_f ();
   init_d ();
 
    
   int p,x;
   scanf ("%d",&x);
   int ans=0,max_h=0;
   double min_ratio=INF;

   rep (i,1,n) {
       int la,lb;
       solve (i,x,la,lb);
       double ration=lb? (double) la/lb:INF;
       if (ration<min_ratio||ration==min_ratio&&h[i]>max_h) {
           min_ratio=ration;
           max_h=h[i];
           ans=i;
       }
   }
   cout<<ans<<endl;
    int m;
    scanf ("%d",&m);
    while (m--) {
        scanf ("%d%d",&p,&x);
        int la,lb;
        solve (p,x,la,lb);
        cout<<la<<" "<<lb<<endl;
    }

   return 0;
}