bzoj 2653 middle (主席树+二分)

版权声明：本文为博主原创文章，未经博主允许不得转载。

 bzoj 2653

题意：

　　一个长度为n的序列a，设其排过序之后为b，其中位数定义为b[n/2]，其中a,b从0开始标号,除法取下整。

　　给你一个长度为n的序列s。

　　回答Q个这样的询问：s的左端点在[a,b]之间,右端点在[c,d]之间的子序列中，最大的中位数。

　　其中a<b<c<d。

　　位置也从0开始标号。

　　强制在线。

解法：

　　首先可以想到的是二分答案，再判断是否满足条件 。

　　对于答案x，我们将原数组中大于等于x的数记1，小于的记为-1，那么一个区间是否满足中位数大于等于x的条件就是区间和大于等于0 。

　　求解子段用线段树就可以快速做到，跟网上的主流做法不同，我线段树节点记录的是区间最大最小前缀和，查询的话只需询问区间[c,d]的最大前缀和 和 [a-1,b-1]的最小前缀和，两者一减就是最大的区间和，再判断它是否大于等于0 。这样子好写，而且效率更高 。（虽然不知道为什么，估计是优化到常数上了，当时是跑了940MS，排到了十三名，之前都没一题排这么前过 。。。）

　　当然不可能对每一个答案x都建立一颗线段树，这时就要用到主席树，按不同的答案x建树 。之后随意搞搞就可以了 _(:з」∠)_

　　

code

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <queue>
#include <set>
#include <vector>
#include <map>
#define LL long long

using namespace std;

const int N=20000+7;

int Ls[N*30],Rs[N*30],dc[N*30],mm[N*30][2]; // 0 最小值  1 最大值
int root[N],tot=0;

struct node{
    int id,key;
    bool operator < (const node &t) const {
        return key<t.key;
    }
}a[N];
int sorted[N];
int n;

inline bool scan_d(int &num)  {
    char in;bool IsN=false;
    in=getchar();
    if(in==EOF) return false;
    while(in!='-'&&(in<'0'||in>'9')) in=getchar();
    if(in=='-'){ IsN=true;num=0;}
    else num=in-'0';
    while(in=getchar(),in>='0'&&in<='9'){
        num*=10,num+=in-'0';
    }
    if(IsN) num=-num;
    return true;
}

inline void pushup(int k){
    mm[k][0]=min(mm[Ls[k]][0],mm[Rs[k]][0])-dc[k];
    mm[k][1]=max(mm[Ls[k]][1],mm[Rs[k]][1])-dc[k];
}

inline int bulidtree(int L,int R){
    int k=tot++;
    dc[k]=0;

    if (L==R){
        mm[k][0]=mm[k][1]=L;
        return k;
    }

    int mid=(L+R)>>1;
    Ls[k]=bulidtree(L,mid);
    Rs[k]=bulidtree(mid+1,R);
    pushup(k);

    return k;
}

inline void COPY(int x,int y){
    dc[x]=dc[y];
    mm[x][0]=mm[y][0];
    mm[x][1]=mm[y][1];
    Ls[x]=Ls[y];
    Rs[x]=Rs[y];
}

inline int update(int o,int x,int y,int L,int R){
    int k=tot++;
    COPY(k,o);
    if (x==L && y==R){
        dc[k]+=2;
        mm[k][0]-=2;
        mm[k][1]-=2;
        return k;
    }

    int mid=(L+R)>>1;
    if (y<=mid) Ls[k]=update(Ls[k],x,y,L,mid);
    else if (x>mid) Rs[k]=update(Rs[k],x,y,mid+1,R);
    else {
        Ls[k]=update(Ls[k],x,mid,L,mid);
        Rs[k]=update(Rs[k],mid+1,y,mid+1,R);
    }
    pushup(k);
    
    return k;
}

inline int query(int o,int x,int y,int L,int R,int op){
    if (L==x && R==y) return mm[o][op];

    int mid=(L+R)>>1;
    if (y<=mid) return query(Ls[o],x,y,L,mid,op)-dc[o];
    else if (x>mid) return query(Rs[o],x,y,mid+1,R,op)-dc[o];
    else {
        if (op==1) return max(query(Ls[o],x,mid,L,mid,op),query(Rs[o],mid+1,y,mid+1,R,op))-dc[o];
        else return min(query(Ls[o],x,mid,L,mid,op),query(Rs[o],mid+1,y,mid+1,R,op))-dc[o];
    }
}

inline bool ok(int x,int a,int b,int c,int d){
    return query(root[x],c,d,0,n,1)-query(root[x],a-1,b-1,0,n,0)>=0;
}

inline int search(int a,int b,int c,int d){
    int L=1,R=n;
    int mid;
    while (L<=R){
        mid=(L+R)>>1;
        if (ok(mid,a,b,c,d)) L=mid+1;
        else R=mid-1;
    }
    return sorted[R];
}

int main(){
    scan_d(n);
    for (int i=1;i<=n;i++){
        scan_d(a[i].key);
        sorted[i]=a[i].key;
        a[i].id=i;
    }
    sort(sorted+1,sorted+n+1);
    sort(a+1,a+n+1);
    
    root[0]=bulidtree(0,n);
    int j=1;
    for (int i=1;i<=n;i++){
        root[i]=root[i-1];
        while (j<=n && a[j].key<sorted[i]){
            root[i]=update(root[i],a[j].id,n,0,n);
            j++;
        }
    }

    int m,q[4],ans=0;
    scan_d(m);
    while (m--){
        for (int i=0;i<4;i++){
            scan_d(q[i]);
            q[i]=(q[i]%n+ans%n)%n+1;
        }
        sort(q,q+4);
        printf("%d
",ans=search(q[0],q[1],q[2],q[3]));
    }
    return 0;
}