BZOJ 2653 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 Description
第一行序列长度$n$.接下来$n$行按顺序给出$a$中的数
接下来一行$Q$.然后$Q$行每行$a,b,c,d$,我们令上个询问的答案是$x$(如果这是第一个询问则$x=0$).
令数组$q=\{(a+x)\mod n,(b+x) \bmod n,(c+x) \bmod n,(d+x) \bmod n\}$
将$q$从小到大排序之后,令真正的要询问$d$的$a=q[0],b=q[1],c=q[2],d=q[3]$
输入保证满足条件
第一行所谓“排过序”指的是从小到大排序!

输出描述 Output Description
Q行依次给出询问的答案

样例输入 Sample Input
5
170337785
271451044
22430280
969056313
206452321
3
3 1 0 2
2 3 1 4
3 1 4 0

样例输出 Sample Output
271451044
271451044
969056313

数据范围及提示 Data Size & Hint
$n<=20000,Q<=25000$

Solution

这是一道很难看出用主席树的主席树
首先如果求中位数的话,一般来说是需要二分答案的
那么我们对于每一个二分出来的答案在序列中将比它小的设为-1,大于等于它的设为1,那么我们只需要区间求和一下就能判断其是否为中位数,若和小于零,那么显然这个数中大于等于它的数多于比它小的数,显然它不是中位数,所以说真正的中位数应该大于它,反之亦然.

但是如果需要多次询问怎么办?
对于每一个二分出来的答案,我们要求的-1,1序列都是相同的.
显然如果我们对于每个答案都建树是会爆炸的
所以上主席树
可以发现排序后修改次数不会超过 n n <script type="math/tex" id="MathJax-Element-96">n</script>次(从全1到全-1)

那么区间是活动的怎么办?
直接将两边的序列看做一个能尽可能多的为中间序列提供答案的子序列(显然越大越好,因为我们要求最大的中位数)
所以利用DP来求左右两端最多能为中间提供多少答案
即求中间序列的总和加上最大右子段和与最大左子段和

这样就愉快的解决了

代码如下:

#include <bits/stdc++.h>
using namespace std;
const int N=20010;
struct T {
    int sum,lsum,rsum,l,r;
    T(){}
    T(int _sum,int _lsum,int _rsum,int _l,int _r) {sum=_sum;lsum=_lsum;rsum=_rsum;l=_l;r=_r;}
}t[N*200];
int cnt;
struct A {int val,id;}a[N];
int n,q,Q[4],ANS;
int root[N];
int read() {
    int ans=0,flag=1;
    char ch=getchar();
    while((ch>'9' || ch<'0') && ch!='-') ch=getchar();
    if(ch=='-') {flag=-1,ch=getchar();}
    while(ch>='0' && ch<='9') {ans=ans*10+ch-'0';ch=getchar();}
    return ans*flag;
}   
void update(int rt) {
    t[rt].sum=t[t[rt].l].sum+t[t[rt].r].sum;
    t[rt].lsum=max(t[t[rt].l].lsum,t[t[rt].l].sum+t[t[rt].r].lsum);
    t[rt].rsum=max(t[t[rt].r].rsum,t[t[rt].r].sum+t[t[rt].l].rsum);
}
void build(int &rt,int l,int r) {
    rt=++cnt;
    if(l==r) {t[rt].sum=t[rt].lsum=t[rt].rsum=1;return;}
    int m=(l+r)>>1;
    build(t[rt].l,l,m);
    build(t[rt].r,m+1,r);
    update(rt);
}
void insert(int &rt,int pos,int l,int r) {
    t[++cnt]=T(t[rt].sum,t[rt].lsum,t[rt].rsum,t[rt].l,t[rt].r);
    rt=cnt;
    if(l==r) {
        t[rt].sum=t[rt].lsum=t[rt].rsum=-1;
        t[rt].l=t[rt].r=0;
        return;
    }
    int m=(l+r)>>1;
    if(pos<=m) insert(t[rt].l,pos,l,m);
    else insert(t[rt].r,pos,m+1,r);
    update(rt);
}
int query_s(int rt,int l,int r,int L,int R) {
    if(L>R) return 0;
    if(L<=l && r<=R) return t[rt].sum;
    int m=(l+r)>>1,ans=0;
    if(L<=m) ans+=query_s(t[rt].l,l,m,L,R);
    if(R>=m+1) ans+=query_s(t[rt].r,m+1,r,L,R);
    return ans;
}
int query_l(int rt,int l,int r,int L,int R) {
    if(L>R) return 0;
    if(L==l && r==R) return t[rt].lsum;
    int m=(l+r)>>1;
    if(R<=m) return query_l(t[rt].l,l,m,L,R);
    if(L>m) return query_l(t[rt].r,m+1,r,L,R);
    return max(query_l(t[rt].l,l,m,L,m),query_s(t[rt].l,l,m,L,m)+query_l(t[rt].r,m+1,r,m+1,R)); 
}
int query_r(int rt,int l,int r,int L,int R) {
    if(L>R) return 0;
    if(L==l && r==R) return t[rt].rsum;
    int m=(l+r)>>1;
    if(R<=m) return query_r(t[rt].l,l,m,L,R);
    if(L>m) return query_r(t[rt].r,m+1,r,L,R);
    return max(query_r(t[rt].r,m+1,r,m+1,R),query_s(t[rt].r,m+1,r,m+1,R)+query_r(t[rt].l,l,m,L,m));
}
bool check(int m) {
    return query_s(root[m],1,n,Q[1],Q[2])+max(query_r(root[m],1,n,Q[0],Q[1]-1),0)+max(query_l(root[m],1,n,Q[2]+1,Q[3]),0)>=0;
}
bool cmp(A a,A b) {return a.val<b.val;}
int main() {
    n=read();
    for(int i=1;i<=n;i++) {a[i].val=read();a[i].id=i;}
    stable_sort(a+1,a+n+1,cmp);
    build(root[1],1,n);
    for(int i=2;i<=n;i++) {
        root[i]=root[i-1];
        insert(root[i],a[i-1].id,1,n);
    }
    q=read();
    while(q--) {
        Q[0]=read();Q[1]=read();Q[2]=read();Q[3]=read();
        Q[0]=(Q[0]+ANS)%n+1;Q[1]=(Q[1]+ANS)%n+1;
        Q[2]=(Q[2]+ANS)%n+1;Q[3]=(Q[3]+ANS)%n+1;
        sort(Q,Q+4);
        int l=1,r=n,m;
        while(l<=r) {
            m=(l+r)>>1;
            if(check(m)) {ANS=m;l=m+1;}
            else r=m-1;
        }
        ANS=a[ANS].val;
        printf("%d\n",ANS);
    }
    return 0;
}