[BZOJ2653]middle-主席树

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

Sample Output

271451044
271451044
969056313

HINT

0:n,Q<=100

1,…,5:n<=2000

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

---

WA了两发以后微妙地觉得这题面的最后一句话略欠扁……

---

思路:
考虑看到中位数所需的必备条件反射：转换成+-1序列求和
(其实咱只是最近经常听说这个方法而已)
也就是二分中位数，把询问区间中大于中位数的数设为1，小于中位数的数设为-1。
若区间求和>0则调整左区间，否则调整右区间。

那么考虑在这题在只有单次询问的情况下怎么做:
发现其实只是把判断使用的值从区间求和，变成了[b+1,c-1]的和以及[a,b]的最大后缀，[c,d]的最大前缀~
那么显然可以采用线段树维护区间最大，最大前缀和后缀，使用时直接查询~
当然，维护的是+-1了~

考虑到咱是要二分中位数。
那么咱需要兹瓷修改。

发现每次咱需要修改一串排序后大小连续的值，将它们同时乘上-1。
那么考虑先sort一波，然后直接按顺序枚举要修改的每个位置并单点修改??
显然将会得到不科学的复杂度，更何况还是多组询问。

可以发现，因为是连续的，所以这样的线段树最多有N个不同的状态。
那么咱可以预处理出这N个状态下的线段树。
考虑到压空间的需要，选择使用主席树。
那么这就做完了~

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>

using namespace std;

inline int read()
{
    int x=0;char ch=getchar();
    while(ch<'0' || '9'<ch)ch=getchar();
    while('0'<=ch && ch<='9')x=x*10+(ch^48),ch=getchar();
    return x;
}

const int N=20009;
const int M=N*60;

struct node
{
    int id,val;
    bool operator < (node o)const
    {
        return val<o.val;
    }
}a[N];

int n,q,qu[5],lans=0;
int root[N],tot;
int t[M][3],ls[M],rs[M];

inline void update(int x)
{
    t[x][0]=t[ls[x]][0]+t[rs[x]][0];
    t[x][1]=max(t[rs[x]][1],t[ls[x]][1]+t[rs[x]][0]);//lmax
    t[x][2]=max(t[ls[x]][2],t[rs[x]][2]+t[ls[x]][0]);//rmax
}

inline int build(int l,int r)
{
    int now=++tot;
    if(l==r)
    {
        t[now][0]=t[now][1]=t[now][2]=1;
        return now;
    }
    int mid=l+r>>1;
    ls[now]=build(l,mid);
    rs[now]=build(mid+1,r);
    update(now);
    return now;
}

inline int insert(int pre,int l,int r,int pos)
{
    int now=++tot;
    ls[now]=ls[pre];
    rs[now]=rs[pre];
    t[now][0]=t[pre][0];
    t[now][1]=t[pre][1];
    t[now][2]=t[pre][2];
    if(l==r)
    {
        t[now][0]=t[now][1]=t[now][2]=-1;
        return now;
    }
    int mid=l+r>>1;
    if(pos<=mid)
        ls[now]=insert(ls[pre],l,mid,pos);
    else
        rs[now]=insert(rs[pre],mid+1,r,pos);
    update(now);
    return now;
}

inline int query(int x,int l,int r,int dl,int dr,int ty)
{
    if(dl>dr)return 0;
    if(dl==l && r==dr)
        return t[x][ty];
    int mid=l+r>>1;
    if(dr<=mid)
        return query(ls[x],l,mid,dl,dr,ty);
    if(mid<dl)
        return query(rs[x],mid+1,r,dl,dr,ty);
    if(ty==0)
        return query(ls[x],l,mid,dl,mid,ty)+query(rs[x],mid+1,r,mid+1,dr,ty);
    if(ty==1)
        return max(query(ls[x],l,mid,dl,mid,ty)+query(rs[x],mid+1,r,mid+1,dr,0),query(rs[x],mid+1,r,mid+1,dr,ty));
    return max(query(ls[x],l,mid,dl,mid,ty),query(rs[x],mid+1,r,mid+1,dr,ty)+query(ls[x],l,mid,dl,mid,0));
}

inline bool check(int mid)
{
    int lfmax=query(root[mid],1,n,qu[1],qu[2],1);
    int rimax=query(root[mid],1,n,qu[3],qu[4],2);
    int misum=query(root[mid],1,n,qu[2]+1,qu[3]-1,0);
    if(lfmax+rimax+misum>=0)
        return true;
    return false;
}

int main()
{
    n=read();
    for(int i=1;i<=n;i++)
        a[i].val=read(),a[i].id=i;
    sort(a+1,a+n+1);

    root[1]=build(1,n);
    for(int i=2;i<=n;i++)
        root[i]=insert(root[i-1],1,n,a[i-1].id);

    q=read();
    while(q--)
    {
        for(int i=1;i<=4;i++)
            qu[i]=(read()+lans)%n+1;

        sort(qu+1,qu+4+1);

        int l=1,r=n,mid;
        lans=1;
        while(l<=r)
        {
            mid=l+r>>1;
            if(check(mid))
                l=mid+1,lans=mid;
            else
                r=mid-1;
        }

        printf("%d\n",lans=a[lans].val);
    }

    return 0;
}