double t;
if(dis1==0) t=MIN;
else t=dis2/dis1*1.0;
if(t<ans)
{
ans=t,s0=i;
}
}
}
void work2()
{
ll d1,d2;
for(re int i=1;i<=m;++i)
{
int now=s[i];
d1=d2=0;
for(re int j=1;j<=n;++j)
{
if(j&1)//是奇数 找次小
{
if(d1+d2+abs(h[nxt2[now]]-h[now])>x[i]) break;
if(!nxt2[now]) break;
d2+=(ll)abs(h[nxt2[now]]-h[now]);
now=nxt2[now];
}
else//找最小
{
if(d1+d2+abs(h[nxt1[now]]-h[now])>x[i]) break;
if(!nxt1[now]) break;
d1+=(ll)abs(h[nxt1[now]]-h[now]);
now=nxt1[now];
}
}
ans1[i]=d1,ans2[i]=d2;
}
}
int main()
{
n=read();
for(re int i=1;i<=n;++i) h[i]=read();
x0=read();
m=read();
for(re int i=1;i<=m;++i)
s[i]=read(),x[i]=read();
pre();
work1();
printf("%d
",s0);
work2();
for(re int i=1;i<=m;++i)
printf("%lld %lld
",ans2[i],ans1[i]);
return 0;
}
要是考试有着暴力分不肯定不去想正解
#$100pts$
注意到两个瓶颈在于初始化和跳的操作，看这个数据我们需要优化成$O(nlogn)$
所以很容易想到跳的操作可以使用倍增优化
那么什么时候可以使用倍增优化呢
>**当不断进行类似的过程且不存在最优解时可以使用**
比如求和、求最值、求最终位置、求距离等等
在这个题中，当谁在开车一定时，每一个位置的后继是一定的，走的距离也是一定的，所以这个过程可以用倍增优化掉
设走的总步数是$2^j$不便于转移，因为会出现总步数是$1$，还要判断是谁走的情况，所以设每个人分别走了$2^j$步
代码还是比较简单的，注意分清每个数组的意义，别搞混了
void pre2()//倍增预处理
{
for(re int i=1;i<=n;++i)
{
//d2[i]表示i后的次小距离,d1[i]表示最小距离
//d4[i][j]表示从i开始,A,B分别开(1<<j)步A一个人的路程
//d5[i][j]表示从i开始,A,B分别开(1<<j)步B一个人的路程
//d3[i][j]表示从i开始,A,B分别开(1<<j)步A,B总路程
d4[i][0]=d2[i];
d5[i][0]=d1[nxt2[i]];
d3[i][0]=d4[i][0]+d5[i][0];
nxt[i][0]=nxt1[nxt2[i]];
//nxt1[i]表示B开车的下一个城市，nxt2[i]表示A开车的下一个城市
//nxt[i][j]表示i开始,A,B分别开(1<<j)步，最终位置
}
for(re int j=1;j<=20;++j)//注意从小到大放到外层枚举
for(re int i=1;i<=n;++i)
{
nxt[i][j]=nxt[nxt[i][j-1]][j-1];
if(!nxt[i][j]) continue;//如果出去了就不用算距离了
d3[i][j]=d3[i][j-1]+d3[nxt[i][j-1]][j-1];
d4[i][j]=d4[i][j-1]+d4[nxt[i][j-1]][j-1];
d5[i][j]=d5[i][j-1]+d5[nxt[i][j-1]][j-1];
}
}
使用倍增跳的过程是这样的：先让两个一起跳，即走$d3[i][j]$，判断是否超距离，是否越界，最后如果还能走就只能让$A$开一次了，所以判断一下即可。
这样跳的过程复杂度就变成了$O(nlogn)$，但预处理的过程仍然是$O(n^2)$的，所以必须优化这个过程
讲道理这道题倍增比预处理过程的优化要好像，要用到**双向链表**
**一般要用到双向链表的地方是将一个数组位置快速删除且能正常遍历，且删除的目的是让前面扫描过元素的不再被考虑**（很重要的性质）
比如这道题，我们预处理时可以先开结构体按海拔排序，记录他们原来的位置，再开个桶记录原来位置到现在结构体下标的映射。在原来数组从左向右扫描，设它在结构体中的位置是$pos[i]$，它的次近和最近海拔一定是在$pos[i]-2,pos[i]-1,pos[i]+1pos[i]+2$(因为极端情况是两个都在一边)。然后在这四个位置上找最小值次小值就行（注意判断越界的情况），然后把$pos[i]$删去，**这样才能保证下一次寻找时不会考虑到原来数组中在它左边元素**，这些操作用双向链表可以很好完成。
所以这道题就$AC$了，总的来说，暴力分很足，难点在于双向链表和倍增
#$100pts Code$
include
include
include
include
include
define re register
define maxn 100100
define MIN 2147483647
define ll long long
using namespace std;
inline int read()
{
int x=0,f=1; char ch=getchar();
while(ch<'0'||ch>'9'){if(ch'-')f=-1;ch=getchar();}
while(ch>='0'&&ch<='9'){x=x10+ch-'0';ch=getchar();}
return xf;
}
struct Cup{
ll h;
int l,r,pos;
}City[maxn];
bool cmp(Cup A,Cup B)
{
return A.h<B.h;
}
int s[maxn],x[maxn],x0,s0,n,m,tmp1,tmp2,tmp3,tmp4,pos1,pos2;
int nxt1[maxn],nxt2[maxn],post[maxn],c[120],nxt[maxn][23];
ll ans1[maxn],ans2[maxn],d1[maxn],d2[maxn],d3[maxn][23],d4[maxn][23],d5[maxn][23];
double ans=MIN,dis1,dis2;
bool CMP(ll a,ll b,ll c,ll d)//按关键字比较
{
if(a<c) return true;
else if(ac&&b<d) return true;
return false;
}
void del(int id)//双向链表
{
City[City[id].l].r=City[id].r;
City[City[id].r].l=City[id].l;
}
void pre()
{
for(re int i=1;i<=n;++i)
{
tmp1=tmp2=tmp3=tmp4=MIN;
pos1=pos2=0;
int tmp=post[i];//表示他在结构体中的位置
c[1]=City[tmp].l,c[2]=City[City[tmp].l].l;
c[3]=City[tmp].r,c[4]=City[City[tmp].r].r;
for(re int j=1;j<=4;++j)
{
int now=c[j];
if(now0||nown+1) continue;//这里注意要判断全了
if(CMP(abs(City[tmp].h-City[now].h),City[now].h,tmp1,tmp3))//找最小值次小值,tmp1是最小距离,tmp3是最小距离的海拔,tmp2,tmp4是次小
{
tmp2=tmp1,tmp4=tmp3,pos2=pos1;
tmp1=abs(City[tmp].h-City[now].h);
tmp3=City[now].h;
pos1=now;
}
else if(CMP(abs(City[tmp].h-City[now].h),City[now].h,tmp2,tmp4))
{
tmp2=abs(City[tmp].h-City[now].h);
tmp4=City[now].h;
pos2=now;
}
}
nxt1[i]=City[pos1].pos,nxt2[i]=City[pos2].pos;//注意这里的i,City[pos1].pos都是原数组位置
d1[i]=tmp1,d2[i]=tmp2;
del(tmp);//删除
}
}
void pre2()//倍增预处理
{
for(re int i=1;i<=n;++i)
{
//d2[i]表示i后的次小距离,d1[i]表示最小距离
//d4[i][j]表示从i开始,A,B分别开(1<<j)步A一个人的路程
//d5[i][j]表示从i开始,A,B分别开(1<<j)步B一个人的路程
//d3[i][j]表示从i开始,A,B分别开(1<<j)步A,B总路程
d4[i][0]=d2[i];
d5[i][0]=d1[nxt2[i]];
d3[i][0]=d4[i][0]+d5[i][0];
nxt[i][0]=nxt1[nxt2[i]];
//nxt1[i]表示B开车的下一个城市，nxt2[i]表示A开车的下一个城市
//nxt[i][j]表示i开始,A,B分别开(1<<j)步，最终位置
}
for(re int j=1;j<=20;++j)//注意从小到大放到外层枚举
for(re int i=1;i<=n;++i)
{
nxt[i][j]=nxt[nxt[i][j-1]][j-1];
if(!nxt[i][j]) continue;//如果出去了就不用算距离了
d3[i][j]=d3[i][j-1]+d3[nxt[i][j-1]][j-1];
d4[i][j]=d4[i][j-1]+d4[nxt[i][j-1]][j-1];
d5[i][j]=d5[i][j-1]+d5[nxt[i][j-1]][j-1];
}
}
void work1()//找点
{
int tmp=x0;
for(re int i=1;i<=n;++i)
{
dis1=dis2=0;
int now=i;
x0=tmp;
for(re int j=20;j>=0;--j)//按上面的方法走就行
{
if(nxt[now][j]0||x0-d3[now][j]<0) continue;
x0-=d3[now][j],dis1+=d5[now][j],dis2+=d4[now][j];
now=nxt[now][j];
}
if(nxt2[now]!=0&&x0-d2[now]>=0) dis2+=d2[now];//小A还能再走
double t;
if(dis1<=1e-7) t=MIN;//不要写if(dis0)，因为有精度问题，还有t要赋值足够大
else t=1.0*dis2/dis1;
if(t<ans) ans=t,s0=i;
}
}
void work2()
{
for(re int i=1;i<=m;++i)
{
int now=s[i];
for(re int j=20;j>=0;--j)
{
if(nxt[now][j]==0||x[i]-d3[now][j]<0) continue;
ans1[i]+=d5[now][j],ans2[i]+=d4[now][j],x[i]-=d3[now][j];
now=nxt[now][j];
}
if(nxt2[now]!=0&&x[i]-d2[now]>=0) ans2[i]+=d2[now];
}
}
int main()
{
n=read();
for(re int i=1;i<=n;++i)
{
City[i].h=read();
City[i].pos=i;//它在结构体中的位置->原位置
}
sort(City+1,City+1+n,cmp);
for(re int i=1;i<=n;++i)
{
post[City[i].pos]=i;//原位置->它在结构体中的位置
City[i].l=i-1;
City[i].r=i+1;
}
pre();
pre2();
x0=read();
m=read();
for(re int i=1;i<=m;++i)
s[i]=read(),x[i]=read();
work1();
printf("%d
",s0);
work2();
for(re int i=1;i<=m;++i)
printf("%lld %lld
",ans2[i],ans1[i]);
return 0;
}