【BZOJ2653】【主席树+二分】middle

Description

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

Input

　　第一行序列长度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]。
　　输入保证满足条件。

Output

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

Sample Input

5
170337785
271451044
22430280
969056313
206452321
3
3 1 0 2
2 3 1 4
3 1 4 0

271451044
271451044
969056313

Sample Output

Hint

　　0:n,Q<=100

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

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

Source

【分析】

居然wa了一下TAT.

比较简单的题目，按照权值大小初始化一下线段树将其可持久化，对于二分的版本求前缀和的最大最小值减一下看是否大于等于0就可以了。

 /*
 唐代贾岛
 《剑客 / 述剑》
 十年磨一剑，霜刃未曾试。
 今日把示君，谁有不平事？
 */
 #include <iostream>
 #include <cstdio>
 #include <algorithm>
 #include <cstring>
 #include <vector>
 #include <utility>
 #include <iomanip>
 #include <string>
 #include <cmath>
 #include <queue>
 #include <assert.h>
 #include <map>
 #include <ctime>
 #include <cstdlib>
 #include <stack>
 #define LOCAL
 const int INF = 0x7fffffff;
 const int MAXN =   + ;
 const int maxnode =  *  +  * ;
 const int maxm=  *  + ;
 using namespace std;
 struct DATA{
        int num;
        int order;
        bool operator < (const DATA &b)const{
             return num < b.num;
        }
 }sorted[MAXN];
 int data[MAXN];
 struct Node{
        int l, r;
        int Max, val, sum, Min;
        Node *ch[];
 }*root[MAXN], mem[maxnode];
 int tot, n;

 Node *NEW(int l, int r){
      Node *p = &mem[tot++];
      p->l = l;
      p->r = r;
      p->val = p->sum = p->Max = p->Min = ;
      p->ch[] = p->ch[] = NULL;
      return p;
 }
 void update(Node *&t){
      if (t->l == t->r) return;
      t->sum = ;
      if (t->ch[] != NULL) t->sum += t->ch[]->sum;
      if (t->ch[] != NULL) t->sum += t->ch[]->sum;

      t->Max = max(t->ch[]->Max + t->ch[]->sum, t->ch[]->Max);
      t->Min = min(t->ch[]->Min + t->ch[]->sum, t->ch[]->Min);
      return;
 }
 void build(Node *&t, int l, int r){
      if (t == NULL){
         t = NEW(l, r);
      }
      if (l == r) return;
      int mid = (l + r) >> ;
      build(t->ch[], l, mid);
      build(t->ch[], mid + , r);
      update(t);
 }
 //将l改为-1
 void change(Node *&t, Node *&last, int l){
      if (t == NULL){
            t = NEW(last->l, last->r);
            t->val = last->val;
            t->Max = last->Max;
            t->Min = last->Min;
            t->sum = last->sum;
      }
      if (t->l == l && t->r == l){
         t->Min = t->Max = t->sum = -;
         return;
      }
      int mid = (t->l + t->r) >> ;
      if (l <= mid){
         change(t->ch[], last->ch[], l);
         t->ch[] = last->ch[];
      }else{
         change(t->ch[], last->ch[], l);
         t->ch[] = last->ch[];
      }
      update(t);
 }
 int qSum(Node *t, int l, int r){
     if (l > r) return ;
     if (l == ) return qSum(t, l + , r);

     if (l <= t->l && t->r <= r) return t->sum;
     int mid = (t->l + t->r) >>;
     int sum = ;
     if (l <= mid) sum += qSum(t->ch[], l, r);
     if (r > mid) sum += qSum(t->ch[], l, r);
     return sum;
 }
 int qMax(Node *t, int l, int r, int k){
      if (l == ) return max(, qMax(t, l + , r, k));

      if (l <= t->l && t->r <= r) return t->Max + qSum(root[k], , t->l - );
      int mid = (t->l + t->r) >> ;
      int Ans = -INF;
      if (l <= mid) Ans = max(Ans, qMax(t->ch[], l, r, k));
      if (r > mid) Ans = max(Ans, qMax(t->ch[], l, r, k));
      return Ans;
 }
 int qMin(Node *t, int l, int r, int k){
      if (l == ) return min(, qMin(t, l + , r, k));

      if (l <= t->l && t->r <= r) return t->Min + qSum(root[k], , t->l - );
      int mid = (t->l + t->r) >> ;
      int Ans = INF;
      if (l <= mid) Ans = min(Ans, qMin(t->ch[], l, r, k));
      if (r > mid) Ans = min(Ans, qMin(t->ch[], l, r, k));
      return Ans;
 }

 void init(){
      scanf("%d", &n);
      for (int i = ; i <= n; i++){
          sorted[i].order = i;
          scanf("%d", &sorted[i].num);
          data[i] = sorted[i].num;
      }
      //离散化
      sort(sorted + , sorted +  + n);

      tot = ;
      root[] = NULL;
      build(root[], , n);
      //开始可持久化
      for (int i = ; i <= (n + ); i++) change(root[i], root[i - ], sorted[i - ].order);
      //printf("%d", root[6]->Max);
      /*int cnt = 0;
      for (int i = 1; i <= n; i++){
          if (i == 0 || sorted[i].num != sorted[i - 1].num) cnt++;
          rem[cnt] = sorted[i].num;
          data[sorted[i].order] = cnt;
      }*/
      //for (int i = 1; i <= n; i++)
 }
 int search(int a, int b, int c, int d){
     int Ans, l = , r = n;
     while (l <= r){
           int mid = (l + r) >> ;
           if ((qMax(root[mid], c, d, mid) - qMin(root[mid], a, b, mid)) >= ) Ans = mid, l = mid + ;
           else r = mid - ;
     }
     return Ans;
 }
 void work(){
      int last_ans = , m;
      scanf("%d", &m);
      for (int i = ; i <= m; i++){
          int q[];
          for (int j = ; j <= ; j++){
              scanf("%d", &q[j]);
              q[j] = (q[j] + last_ans) % n;
          }
          sort(q + , q +  + );
          int a = q[], b = q[], c = q[], d = q[];
          a++;c++;
          b++;d++;
          //printf("%d", qMax(root[5], 3, 3, 5));
          //printf("%d%d%d%d\n", a, b, c, d);
          last_ans = sorted[search(a - , b - , c, d)].num;
          printf("%d\n", last_ans);
      }
 }

 int main (){

     init();
     work();
     return ;
 }