[cf765F]Souvenirs

离线，从小到大枚举右端点，维护左端点的答案，那么当右端点从$r-1$变为$r$时，即在原来的基础上考虑其中一个数为$a_{r}$的答案，并对原来的答案取$\min$

考虑另一个数为$a_{i}$，这里仅考虑$a_{r}\le a_{i}$的情况（$a_{r}\ge a_{i}$类似）：

此时，先找到最大的$1\le i_{1}<r$使得$a_{r}\le a_{i_{1}}$，不妨先对$[1,i_{1}]$的答案都用$a_{i_{1}}-a_{r}$去更新

接下来，注意到如果$a_{i_{2}}\ge \lceil\frac{a_{r}+a_{i_{1}}}{2}\rceil$则有$|a_{i_{1}}-a_{i_{2}}|\le a_{i_{2}}-a_{r}$，即其一定没有意义，那么只需要找到最大的$1\le i_{2}<i_{1}$使得$a_{r}\le a_{i_{2}}<\lceil\frac{a_{r}+a_{i_{1}}}{2}\rceil$即可

重复此过程，即不断找到最大的$1\le i_{t}<i_{t-1}$使得$a_{r}\le a_{i_{t}}<\lceil\frac{a_{r}+a_{i_{t-1}}}{2}\rceil$，由于$0\le a_{i_{t}}-a_{r}<\lceil\frac{a_{t-1}-a_{r}}{2}\rceil$，因此最多找$o(\log V)$次，每一次用线段树维护可以做到$o(\log V)$（其中$V$为值域）

关于线段树，可持久化常数过大，需要将权值离散并在线维护每种权值最后一次出现的位置

总复杂度即$o(n\log^{2}V+m\log n)$，可以通过

#include<bits/stdc++.h>
using namespace std;
#define N 100005
#define L (k<<1)
#define R (L+1)
#define mid (l+r>>1)
vector<pair<int,int> >v[N];
int n,m,x,y,l,r,a[N],b[N],pos[N<<2],f[N],ans[N<<2];
int lowbit(int k){
    return (k&(-k));
}
void update(int k,int x){
    while (k){
        f[k]=min(f[k],x);
        k^=lowbit(k); 
    }
}
int query(int k){
    int ans=f[0];
    while (k<=n){
        ans=min(ans,f[k]);
        k+=lowbit(k);
    }
    return ans;
}
void update(int k,int l,int r,int x,int y){
    pos[k]=max(pos[k],y);
    if (l==r)return;
    if (x<=mid)update(L,l,mid,x,y);
    else update(R,mid+1,r,x,y);
}
int query(int k,int l,int r,int x,int y){
    if ((l>y)||(x>r))return 0;
    if ((x<=l)&&(r<=y))return pos[k];
    return max(query(L,l,mid,x,y),query(R,mid+1,r,x,y));
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%d",&a[i]);
    scanf("%d",&m);
    for(int i=1;i<=m;i++){
        scanf("%d%d",&x,&y);
        v[y].push_back(make_pair(x,i));
    }
    memcpy(b,a,sizeof(a));
    memset(f,0x3f,sizeof(f));
    sort(b+1,b+n+1);
    for(int i=1;i<=n;i++){
        int pos=lower_bound(b+1,b+n+1,a[i])-b;
        l=pos,r=n;
        while (1){
            int Pos=query(1,1,n,l,r);
            if (!Pos)break;
            update(Pos,a[Pos]-a[i]);
            r=upper_bound(b+1,b+n+1,(a[i]+a[Pos]-1>>1))-b-1;
        }
        l=1,r=pos;
        while (1){
            int Pos=query(1,1,n,l,r);
            if (!Pos)break;
            update(Pos,a[i]-a[Pos]);
            l=upper_bound(b+1,b+n+1,(a[i]+a[Pos]>>1))-b;
        }
        update(1,1,n,pos,i);
        for(int j=0;j<v[i].size();j++)ans[v[i][j].second]=query(v[i][j].first);
    }
    for(int i=1;i<=m;i++)printf("%d\n",ans[i]);
    return 0;
}