BZOJ2221: [Jsoi2009]面试的考验

传送门

一句话题意，给定一个序列，询问区间内差值的绝对值的最小值。

这道题之前见过一次，似乎是在一次UER上，那一道题当时是用了近似算法才能过。

数据保证数列随机。

这道题显然非常适合离线的做法，考虑对于没对数来计算贡献。

我们知道在整个序列中一共有$O(N^2)$对数，在所有询问中，有些对的数对询问是无法做出贡献的，考虑如何在离线统计时排除这些数的干扰。

假设一个位置$a_i$，我们考虑$|a_j-a_i|(j<i)$，显然，如果我们能在$a_i$前找到一段递减子序列且$\forall a_j <a_i$，那么这个子序列都会对存在的询问产生贡献。

递增同理。

因为数列随机，我们可以得到这样一个性质：任意$a_i$前的递增/递减序列长度不会超过$logN$。

所以我们维护一颗权值线段树，每次在树上找到坐标最大的点，然后缩小范围再次寻找，这样就保证了递减。

这样的话就可以从左往右扫一遍，再建一颗线段树存答案，把询问按右端点排序后统计答案即可。

//BZOJ2221
//by Cydiater
//2017.2.15
#include <iostream>
#include <queue>
#include <map>
#include <cstring>
#include <string>
#include <cmath>
#include <ctime>
#include <cstdlib>
#include <cstdio>
#include <iomanip>
#include <algorithm>
#include <bitset>
#include <set>
#include <vector>
#include <complex>
using namespace std;
#define ll long long
#define up(i,j,n)	for(int i=j;i<=n;i++)
#define down(i,j,n)	for(int i=j;i>=n;i--)
#define cmax(a,b)	a=max(a,b)
#define cmin(a,b)	a=min(a,b)
const int MAXN=5e5+5;
const int oo=2147483647;
inline int read(){
	char ch=getchar();int x=0,f=1;
	while(ch>'9'||ch<'0'){if(ch=='-')f=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
	return x*f;
}
int N,M,arr[MAXN],b[MAXN],top,_b[MAXN];
struct Query{
	int x,y,ans,id;
}query[MAXN];
struct SGT{
	struct sgt{
		int tmax,tmin,Max,Min;
	}t[MAXN<<2];
	inline void reload(int root){
		t[root].Max=max(t[root<<1].Max,t[root<<1|1].Max);
		t[root].Min=min(t[root<<1].Min,t[root<<1|1].Min);
	}
	inline void Pushdown(int root){
		int tmax=t[root].tmax,tmin=t[root].tmin;
		t[root].tmax=-1;t[root].tmin=oo;
		if(tmax!=-1){
			cmax(t[root<<1].tmax,tmax);cmax(t[root<<1].Max,tmax);
			cmax(t[root<<1|1].tmax,tmax);cmax(t[root<<1|1].Max,tmax);
		}
		if(tmin!=oo){
			cmin(t[root<<1].tmin,tmin);cmin(t[root<<1].Min,tmin);
			cmin(t[root<<1|1].tmin,tmin);cmin(t[root<<1|1].Min,tmin);
		}
	}
	void Build(int leftt,int rightt,int root,int val){
		t[root].tmax=-1;t[root].tmin=oo;
		if(leftt==rightt){
			t[root].Max=t[root].Min=val;
			return;
		}
		int mid=(leftt+rightt)>>1;
		Build(leftt,mid,root<<1,val);
		Build(mid+1,rightt,root<<1|1,val);
		reload(root);
	}
	int Max(int leftt,int rightt,int root,int L,int R){
		int mid=(leftt+rightt)>>1;
		if(leftt!=rightt)Pushdown(root);
		if(leftt>=L&&rightt<=R)	return t[root].Max;
		if(L<=mid&&mid+1<=R)	return max(Max(leftt,mid,root<<1,L,R),Max(mid+1,rightt,root<<1|1,L,R));
		else if(L<=mid)		return Max(leftt,mid,root<<1,L,R);
		else if(mid+1<=R)	return Max(mid+1,rightt,root<<1|1,L,R);
	}
	int Min(int leftt,int rightt,int root,int L,int R){
		int mid=(leftt+rightt)>>1;
		if(leftt!=rightt)Pushdown(root);
		if(leftt>=L&&rightt<=R)	return t[root].Min;
		if(L<=mid&&mid+1<=R)	return min(Min(leftt,mid,root<<1,L,R),Min(mid+1,rightt,root<<1|1,L,R));
		else if(L<=mid)		return Min(leftt,mid,root<<1,L,R);
		else if(mid+1<=R)	return Min(mid+1,rightt,root<<1|1,L,R);
	}
	void Modify(int leftt,int rightt,int root,int L,int R,int val){
		int mid=(leftt+rightt)>>1;
		if(leftt!=rightt)Pushdown(root);
		if(leftt>=L&&rightt<=R){
			cmax(t[root].Max,val);
			cmin(t[root].Min,val);
			cmax(t[root].tmax,val);
			cmin(t[root].tmin,val);
			return;
		}
		if(L<=mid)		Modify(leftt,mid,root<<1,L,R,val);
		if(mid+1<=R)		Modify(mid+1,rightt,root<<1|1,L,R,val);
		reload(root);
	}
}T1,T2;
namespace solution{
	inline bool cmp(Query x,Query y){return x.y<y.y;}
	inline bool cmpx(Query x,Query y){return x.id<y.id;}
	void Change(int pos){
		int vpos=arr[pos];
		up(L,1,vpos-1){
			int val=T1.Max(1,top,1,L,vpos-1);
			if(val==-oo)break;
			else	T2.Modify(1,N,1,1,val,abs(b[arr[pos]]-b[arr[val]]));
			L=arr[val];
		}
		down(R,top,vpos+1){
			int val=T1.Max(1,top,1,vpos+1,R);
			if(val==-oo)break;
			else T2.Modify(1,N,1,1,val,abs(b[arr[pos]]-b[arr[val]]));
			R=arr[val];
		}
		T1.Modify(1,top,1,vpos,vpos,pos);
	}
	void Prepare(){
		N=read();M=read();
		up(i,1,N)b[i]=arr[i]=read();
		up(i,1,M){
			query[i].x=read();query[i].y=read();query[i].id=i;
		}
		sort(query+1,query+M+1,cmp);
		sort(b+1,b+N+1);
		top=unique(b+1,b+N+1)-(b+1);
		up(i,1,N)arr[i]=lower_bound(b+1,b+top+1,arr[i])-b;
		T1.Build(1,top,1,-oo);
		T2.Build(1,N,1,oo);
	}
	void Solve(){
		int pos=0;
		up(i,1,M){
			int LIM=query[i].y;
			while(pos<LIM)Change(++pos);
			query[i].ans=T2.Min(1,N,1,query[i].x,query[i].y);
		}
		sort(query+1,query+M+1,cmpx);
		up(i,1,M){
			printf("%d\n",query[i].ans);
		}
	}
}
int main(){
	//freopen("input.in","r",stdin);
	using namespace solution;
	Prepare();
	Solve();
	return 0;
}