一个长度为n的序列a，设其排过序之后为b，其中位数定义为b[n/2]，其中a,b从0开始标号,除法取下整。
　　给你一个长度为n的序列s。
　　回答Q个这样的询问：s的左端点在[a,b]之间,右端点在[c,d]之间的子序列中，最大的中位数。
　　其中a<b<c<d。
　　位置也从0开始标号。
　　我会使用一些方式强制你在线。

　　第一行序列长度n。
　　接下来n行按顺序给出a中的数。
　　接下来一行Q。
　　然后Q行每行a,b,c,d，我们令上个询问的答案是x(如果这是第一个询问则x=0)。
　　令数组q={(a+x)%n,(b+x)%n,(c+x)%n,(d+x)%n}。
　　将q从小到大排序之后，令真正的要询问的a=q[0],b=q[1],c=q[2],d=q[3]。
　　输入保证满足条件。

　　Q行依次给出询问的答案。

　　0:n,Q<=100

　　1,...,5:n<=2000

　　0,...,19:n<=20000,Q<=25000

Solution

一道神奇的题目，在长沙培训时初次见面

和一般主席树的做法不尽相同

为了避免枚举中位数，我们将序列排序，对排序后的点建立一颗以整个序列编号为节点的线段树

此后，对于每个有序点的线段树，我们将其内的所有值小于它的点的贡献标记为-1，记录从左边起最大连续和，还有从右边起最大连续和

显然，这个排序后的主席树是满足二分性质的

那么，我们二分中位数，查询区间[B,C]的贡献、[A,B)的右边最大连续和、(C,D]的左边最大连续和是否大于或等于0，若是，则说明它可以构成一个合法的中位数是当前二分值的序列，也说明中位数大于或等于当前此数

最后输出二分答案即可

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <iostream>

#include <algorithm>

#define N 20200

#define mid ((s) + (t) >> (1))

#define dmax(a, b) ((a) > (b) ? (a) : (b))

using namespace std;

inline int Rin(){

  int x = , c = getchar(), f = ;

  for(; c <  || c > ; c = getchar())

    if(!(c ^ ))f = -;

  for(; c >  && c < ; c = getchar())

    x = (x << ) + (x << ) + c - ;

  return x * f;

}

int n;

namespace Arcueid{

  struct Area{

    int lq, rq, sum;

    Area(int x = ){

      lq = rq = dmax(x, );

      sum = x;

    }

  };

  Area operator + (Area a, Area b){

    Area c;

    c.sum = a.sum + b.sum;

    c.lq = dmax(a.lq, a.sum + b.lq);

    c.rq = dmax(b.rq, a.rq + b.sum);

    return c;

  }

  struct Node{

    Node *l, *r;

    Area key;

    Node(){}

    Node(Node *_l, Node *_r, Area _key) : l(_l), r(_r), key(_key) {}

  }*_nil = new Node(), *nil = (*_nil = Node(_nil, _nil, ), _nil), pool[N * ], *top = pool, *rt[N];

  Node *newnode(Node *_, Node *__, Area ___){

    *top = Node(_, __, ___);

    return top++;

  }

  Node *born(int s, int t){

    if(!(s ^ t))return newnode(0x0, 0x0, Area());

    Node *_ = born(s, mid); Node *__ = born(mid + , t);

    return newnode(_, __, _->key + __->key);

  }

  Node *real(Node *p, int s, int t, int k){

    if(!(s ^ t))return newnode(0x0, 0x0, Area(-));

    if(k <= mid){

      Node *_ = real(p->l, s, mid, k);

      return newnode(_, p->r, _->key + p->r->key);

    }

    else{

      Node *_ = real(p->r, mid + , t, k);

      return newnode(p->l, _, p->l->key + _->key);

    }

  }

  Area secret(Node *p, int s, int t, int l, int r){

    if(l == s && t == r)return p->key;

    if(r <= mid)return secret(p->l, s, mid, l, r);

    if(l > mid)return secret(p->r, mid + , t, l, r);

    return secret(p->l, s, mid, l, mid) + secret(p->r, mid + , t, mid + , r);

  }

  bool judge(int A, int B, int C, int D, int k){

    int res = ;

    res += secret(rt[k], , n, B, C).sum;

    res += secret(rt[k], , n, A, B - ).rq;

    res += secret(rt[k], , n, C + , D).lq;

    return res >= ;

  }

  int binsearch(int A, int B, int C, int D){

    int s = , t = n;

    while(s +  < t){

      if(judge(A, B, C, D, mid))

        s = mid;

      else

        t = mid;

    }

    if(judge(A, B, C, D, t))

      return t;

    return s;

  }

}

namespace moon{

  struct dat{

    int key, pos;

    void init(int _) {key = Rin(); pos = _;}

    bool operator < (const dat  h)const{

      return key < h.key;

    }

  }b[N];

  void cause(){

    n = Rin();

    for(int i = ; i <= n; i++)

      b[i].init(i);

    sort(b + , b +  + n);

    Arcueid::rt[] = Arcueid::born(, n);

    for(int i = ; i <= n; i++)

      Arcueid::rt[i] = Arcueid::real(Arcueid::rt[i - ], , n, b[i - ].pos);

    int m = Rin(), ans = , q[];

    while(m--){

      for(int j=;j<;j++)

        q[j] = Rin(), q[j] = (q[j] + ans) % n+;

      sort(q,q+);

      printf("%d\n", ans = b[Arcueid::binsearch(q[],q[],q[],q[])].key);

    }

  }

}

int main(){

  moon::cause();

  return ;

}