【NOIP模拟赛】beautiful 乱搞（平衡树）+ST

biubiu~~~

我用平衡树处理的这道题，然而这种方法还是要看评测姬.....

正解是乱搞....就是枚举每一位数作为中位数，比他小的看做-1比他大的看做1，那么我们从一开始就有了一个绵延的山，我们记录这个数之前出现过的距水平线高度差，如果我们在右边找到了这个同样的距离就意味着我们中间的操作为0那么在这两个相同水平面之前的距离就是他作为中位数的一个区间。

似乎这是一种中位数套路........

#include <cstdio>
namespace Pre{
  inline void read(int &sum){
    register char ch=getchar();
    for(sum=;ch<''||ch>'';ch=getchar());
    for(;ch>=''&&ch<='';sum=(sum<<)+(sum<<)+ch-'',ch=getchar());
  }
  inline int Max(int x,int y){
    return x>y?x:y;
  }
  int a[],n;
  int Ans[];
  int St[][],LOG[],Bin[];
  inline int get_ans(int l,int r){
    int len=r-l+;
    return Max(St[l][LOG[len]],St[r-Bin[LOG[len]]+][LOG[len]]);
  }
}
namespace Point{
  struct point{
    int key,pos;
    inline friend bool operator < (point a,point b);
    inline friend bool operator > (point a,point b);
  }A[];
  inline bool operator < (point a,point b){
    return a.key<b.key||(a.key==b.key&&a.pos<b.pos);
  }
  inline bool operator > (point a,point b){
    return b<a;
  }
}
namespace SGT{
  const double alpha=0.75;
  struct ScapeGoat_Tree{
    ScapeGoat_Tree *ch[];
    int size;
    Point::point key;
    void pushup(){
      size=ch[]->size+ch[]->size+;
    }
    bool isbad(){
      return size*alpha+<ch[]->size||size*alpha+<ch[]->size;
    }
  }*null,*root,mempool[],*stack[],*list[];
  int len,top;
  inline void Init(){
    null=mempool;
    null->ch[]=null->ch[]=null;
    root=null;
    for(int i=;i<;i++)stack[++top]=mempool+i;
  }
  inline ScapeGoat_Tree *New(Point::point key){
    ScapeGoat_Tree *p=stack[top--];
    p->ch[]=p->ch[]=null;
    p->size=;
    p->key=key;
    return p;
  }
  inline void clear(ScapeGoat_Tree *p){
    if(p==null)return;
    clear(p->ch[]);
    clear(p->ch[]);
    stack[++top]=p;
  }
  inline void Clear(){
    clear(root);
    root=null;
  }
  inline void travel(ScapeGoat_Tree *p){
    if(p==null)return;
    travel(p->ch[]);
    list[++len]=p;
    travel(p->ch[]);
  }
  inline ScapeGoat_Tree *divide(int l,int r){
    if(l>r)return null;
    int mid=(l+r)>>;
    list[mid]->ch[]=divide(l,mid-);
    list[mid]->ch[]=divide(mid+,r);
    list[mid]->pushup();
    return list[mid];
  }
  inline void rebuild(ScapeGoat_Tree *&p){
    len=;
    travel(p);
    p=divide(,len);
  }
  inline ScapeGoat_Tree **insert(ScapeGoat_Tree *&p,Point::point key){
    if(p==null){
      p=New(key);
      return &null;
    }
    p->size++;
    ScapeGoat_Tree **ret=insert(p->ch[key>p->key],key);
    if(p->isbad())ret=&p;
    return ret;
  }
  inline void Insert(Point::point key){
    ScapeGoat_Tree **p=insert(root,key);
    if(*p!=null)rebuild(*p);
  }
  inline Point::point get_kth(int k){
    ScapeGoat_Tree *p=root;
    while()
      if(p->ch[]->size>=k)p=p->ch[];
      else if(p->ch[]->size+==k)return p->key;
      else k-=p->ch[]->size+,p=p->ch[];
  }
}
namespace PRE_WORK{
  void Get_Max(){
    using namespace Point;
    for(int i=;i<=Pre::n;i++){
      SGT::Clear();
      Pre::Ans[i]=Pre::Max(,Pre::Ans[i]);
      SGT::Insert(A[i]);
      for(int j=i+;j<=Pre::n;j++){
        SGT::Insert(A[j]);
        if(SGT::root->size&){
          int Num=SGT::get_kth((SGT::root->size+)>>).pos;
          Pre::Ans[Num]=Pre::Max(Pre::Ans[Num],SGT::root->size);
        }
      }
    }
  }
  void Get_ST(){
    using namespace Pre;
    Bin[]=;
    for(int i=;i<;i++)Bin[i]=Bin[i-]<<;
    LOG[]=-;
    for(int i=;i<=n;i++)LOG[i]=LOG[i>>]+;
    for(int i=;i<=n;i++)St[i][]=Ans[i];
    for(int i=;Bin[i]<=n;i++)
      for(int j=;j+Bin[i]-<=n;j++)
        St[j][i]=Max(St[j][i-],St[j+Bin[i-]][i-]);
  }
}
namespace Main{
  inline void Init(){
    SGT::Init();
    using Pre::read;
    read(Pre::n);
    for(int i=;i<=Pre::n;i++){
      read(Pre::a[i]);
      Point::A[i]=(Point::point){Pre::a[i],i};
    }
    PRE_WORK::Get_Max();
    PRE_WORK::Get_ST();
  }
  inline void Work(){
    using namespace Pre;
    int Q;read(Q);
    for(int i=,l,r;i<=Q;i++){
      read(l),read(r);
      printf("%d\n",get_ans(l,r));
    }
  }
}
int main(){
  using namespace Main;
  Init(),Work();
  return ;
}