Luogu2839 Middle 主席树二分答案

Posted 2021-01-11 itst

题目传送门：https://www.luogu.org/problemnew/show/P2839

题目大意：给出一个长度为$N$的序列与$Q$次询问，每次询问左端点在$[a,b]$，右端点在$[c,d]$的区间中最大的中位数，强制在线（本题中的中位数定义与平常不同，设某区间长度为$L$，则在从小到大排序后的序列中（编号从$0$开始），其中位数为第$lfloor L/2 floor$号元素）$N,Q leq 2 imes 10^4$

---

 

这鬼题让我知道主席树可以用于除第$K$大以外的问题$qwq$

观察$100 \%$的数据规模，$O(nQ)$的做法都比较吃力，所以考虑使用$log$数据结构进行维护获得$O(Qlogn)$或者$O(Qlog^2n)$的算法。故考虑到使用线段树进行维护，同时使用二分的方式寻找每个询问的答案，

其中check的内容就是寻找是否有满足该询问条件的区间，在其中（大于等于当前二分的数的数字个数）要大于等于（小于当前二分的数的数字个数）。断句略奇怪
不妨将大于等于当前二分的数的数字的权值设为1，小于当前二分的数的数字的权值设为-1，check的内容就等价于询问$$max(sum_{i=x}^y w_i) geq 0 (x in {[a , b]} , y in{[c , d]})$$是否成立。

所以想到对于每个数字建立一个线段树存储权值，在每一次二分询问时求出对应线段树中$x in {[a , b]} , y in{[c , d]},sum_{i=b+1}^{c-1} w_i + max(sum_{i=x}^b w_i)+max(max(sum_{i=c}^y w_i))$是否大于0，刚好这三个式子对应区间和、区间最大后缀、区间最大前缀，可以使用线段树解决。
然后发现对于排序后的相邻两数只有一个$1$变成$-1$，就可以使用主席树将空间压到允许范围内了
时间复杂度为$O(Qlog^2n)$，空间复杂度为$O(nlogn)$，符合本题数据范围

 

  1 #include<bits/stdc++.h>
  2 #define MAXN 100002
  3 using namespace std;
  4 inline int read(){
  5     int a = 0;
  6     bool f = 0;
  7     char c = getchar();
  8     while(!isdigit(c)){
  9         if(c == ‘-‘)
 10             f = 1;
 11         c = getchar();
 12     }
 13     while(isdigit(c)){
 14         a = (a << 3) + (a << 1) + (c ^ ‘0‘);
 15         c = getchar();
 16     }
 17     return f ? -a : a;
 18 }
 19 char output[12];
 20 inline void print(int x){
 21     int dirN = 11;
 22     if(x == 0)
 23         fwrite("0" , sizeof(char) , 1 , stdout);
 24     else{
 25         if(x < 0){
 26             x = -x;
 27             fwrite("-" , sizeof(char) , 1 , stdout);
 28         }
 29         while(x){
 30                output[--dirN] = x % 10 + 48;
 31             x /= 10;
 32         }
 33         fwrite(output + dirN , 1 , strlen(output + dirN) , stdout);
 34     }
 35     fwrite("
" , 1 , 1 , stdout);
 36 }
 37 struct node{
 38     int sum , lMax , rMax , l , r;
 39 }Tree[22 * MAXN];
 40 struct sortNum{//用于排序
 41     int ind , num;
 42     bool operator <(sortNum a){
 43         return num < a.num;
 44     }
 45 }sorted[MAXN];
 46 int num[MAXN] , root[MAXN];
 47 int N , cntNode = 1 , rMax , rSum , lMax , lSum;
 48 
 49 inline int max(int a , int b){
 50     return a > b ? a : b;
 51 }
 52 
 53 inline void swap(int &a , int &b){
 54     int t = a;
 55     a = b;
 56     b = t;
 57 }
 58 
 59 //初始化一个所有叶子结点权值都为1的线段树
 60 void init(int dir , int l , int r){
 61     Tree[dir].sum = Tree[dir].lMax = Tree[dir].rMax = r - l + 1;
 62     if(l != r){
 63         init(Tree[dir].l = ++cntNode , l , l + r >> 1);
 64         init(Tree[dir].r = ++cntNode , (l + r >> 1) + 1 , r);
 65     }
 66 }
 67 
 68 inline void pushup(int dir){
 69     Tree[dir].lMax = max(Tree[Tree[dir].l].lMax , Tree[Tree[dir].l].sum + Tree[Tree[dir].r].lMax);
 70     Tree[dir].rMax = max(Tree[Tree[dir].r].rMax , Tree[Tree[dir].r].sum + Tree[Tree[dir].l].rMax);
 71     Tree[dir].sum = Tree[Tree[dir].l].sum + Tree[Tree[dir].r].sum;
 72 }
 73 
 74 //更新版本
 75 void update(int now , int last , int l , int r , int dir){
 76     if(l == r){
 77         Tree[now].lMax = Tree[now].rMax = 0;
 78         Tree[now].sum = -1;
 79     }
 80     else{
 81         if(dir > l + r >> 1){
 82             Tree[now].l = Tree[last].l;
 83             update(Tree[now].r = ++cntNode , Tree[last].r , (l + r >> 1) + 1 , r , dir);
 84         }
 85         else{
 86             Tree[now].r = Tree[last].r;
 87             update(Tree[now].l = ++cntNode , Tree[last].l , l , l + r >> 1 , dir);
 88         }
 89         pushup(now);
 90     }
 91 }
 92 
 93 //区间和
 94 int findSum(int dir , int l , int r , int L , int R){
 95     if(L >= l && R <= r)
 96         return Tree[dir].sum;
 97     int sum = 0;
 98     if(l <= L + R >> 1)
 99         sum += findSum(Tree[dir].l , l , r , L , L + R >> 1);
100     if(r > R + L >> 1)
101         sum += findSum(Tree[dir].r , l , r , (L + R >> 1) + 1 , R);
102     return sum;
103 }
104 
105 //区间最大后缀
106 void findRightMax(int dir , int l , int r , int L , int R){
107     if(L >= l && R <= r){
108         rMax = max(rMax , Tree[dir].rMax + rSum);
109         rSum += Tree[dir].sum;
110         return;
111     }
112     if(r > L + R >> 1)
113         findRightMax(Tree[dir].r , l , r , (L + R >> 1) + 1 , R);
114     if(l <= L + R >> 1)
115         findRightMax(Tree[dir].l , l , r , L , L + R >> 1);
116 }
117 
118 //区间最大前缀
119 void findLeftMax(int dir , int l , int r , int L , int R){
120     if(L >= l && R <= r){
121         lMax = max(lMax , Tree[dir].lMax + lSum);
122         lSum += Tree[dir].sum;
123         return;
124     }
125     if(l <= L + R >> 1)
126         findLeftMax(Tree[dir].l , l , r , L , L + R >> 1);
127     if(r > L + R >> 1)
128         findLeftMax(Tree[dir].r , l , r , (L + R >> 1) + 1 , R);
129 }
130 
131 //二分check
132 //为了方便处理这里的代码与上面的公式稍有不同
133 inline bool check(int mid , int a , int b , int c , int d){
134     lSum = rSum = 0;
135     lMax = rMax = -1;
136     findRightMax(root[mid] , a , b - 1 , 1 , N);
137     findLeftMax(root[mid] , c + 1 , d , 1 , N);
138     return findSum(root[mid] , b , c , 1 , N) + lMax + rMax >= 0;
139 }
140 
141 int main(){
142     N = read();
143     long long lastans = 0;
144     for(int i = 1 ; i <= N ; i++)
145         num[sorted[i].ind = i] = sorted[i].num = read();
146     init(root[1] = 1 , 1 , N);
147     sort(sorted + 1 , sorted + N + 1);
148     for(int i = 1 ; i <= N ; i++)
149         update(root[i + 1] = ++cntNode , root[i] , 1 , N , sorted[i].ind); 
150     for(int Q = read() ; Q ; Q--){
151         int a = (read() + lastans) % N + 1 , b = (read() + lastans) % N + 1 , c = (read() + lastans) % N + 1 , d = (read() + lastans) % N + 1;
152         if(a > b)
153             swap(a , b);
154         if(a > c)
155             swap(a , c);
156         if(a > d)
157             swap(a , d);
158         if(b > c)
159             swap(b , c);
160         if(b > d)
161             swap(b , d);
162         if(c > d)
163             swap(c , d);
164         int l = 1 , r = N;
165         while(l < r){
166             int mid = l + r + 1 >> 1;
167             if(check(mid , a , b , c , d))
168                 l = mid;
169             else
170                 r = mid - 1;
171         }
172         printf("%d
" , lastans = sorted[l].num);
173     }
174     return 0;
175 }