[bzoj4552][Tjoi2016][Heoi2016]排序

Description

给出一个\(1\)到\(n\)的全排列,现在对这个全排列序列进行\(m\)次局部排序,排序分为\(2\)种：

\(1.(0,l,r)\)表示将区间\([l,r]\)的数字升序排序;

\(2.(1,l,r)\)表示将区间\([l,r]\)的数字降序排序.

最后询问第\(q\)位置上的数字.

Input

第\(1\)行为两个整数\(n\)和\(m\).\(n\)表示序列的长度,\(m\)表示局部排序的次数.

第\(2\)行为\(n\)个整数,表示\(1\)到\(n\)的一个全排列.

接下来输入\(m\)行,每\(1\)行有\(3\)个整数\(op,l,r\).

\(op\)为\(0\)代表升序排序,\(op\)为\(1\)代表降序排序;\(l,r\)表示排序的区间.

最后输入一个整数\(q\),\(q\)表示排序完之后询问的位置.

Output

输出数据仅有一行一个整数,表示按照顺序将全部的部分排序结束后第\(q\)位置上的数字.

Sample Input

6 3 
1 6 2 5 3 4 
0 1 4 
1 3 6 
0 2 4 
3

Sample Output

5

HINT

\(1\;\leq\;n,m\;\leq\;10^5,1\;\leq\;q\;\leq\;n.\)

Solution

二分答案\(ans\).

把\(\;\leq\;ans\)的位置标为\(1\),其余标为\(0\).

线段树维护排序操作,最后判断位置\(q\)上是否为\(0\).

#include<cmath>
#include<ctime>
#include<queue>
#include<stack>
#include<cstdio>
#include<vector>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#define N 100005
#define M 300005
using namespace std;
struct linetree{
    int l,r,t,op;
}lt[M];
struct quest{
    int op,l,r;
}b[N];
int a[N],n,m,q,t,l,r,mid;
inline void build(int u,int l,int r,int k){
    lt[u].l=l;lt[u].r=r;lt[u].op=0;
    if(lt[u].l<lt[u].r){
        int lef=u<<1,rig=u<<1|1;
        int mid=(lt[u].l+lt[u].r)>>1; 
        build(lef,l,mid,k);build(rig,mid+1,r,k);
        lt[u].t=lt[lef].t+lt[rig].t;
    }
    else if(a[lt[u].l]>=k) lt[u].t=0;
    else lt[u].t=1;
}
inline void cover(int u,int i){
    if(lt[u].l>=b[i].l&&lt[u].r<=b[i].r){
        if(!b[i].op){
            lt[u].op=-1;
            if(lt[u].l-b[i].l+1<=t){
                lt[u].t=min(t-(lt[u].l-b[i].l),lt[u].r-lt[u].l+1);
            }
            else lt[u].t=0;
        }
        else{
            lt[u].op=1;
            if(b[i].r-lt[u].r+1<=t){
                lt[u].t=min(t-(b[i].r-lt[u].r),lt[u].r-lt[u].l+1);
            }
            else lt[u].t=0;
        }
    }
    else if(lt[u].l<lt[u].r){
        int lef=u<<1,rig=u<<1|1;
        int mid=(lt[u].l+lt[u].r)>>1;
        if(lt[u].op>0)/*降序*/{
            lt[u].op=0;lt[lef].op=lt[rig].op=1;
            lt[rig].t=min(lt[u].t,lt[rig].r-lt[rig].l+1);
            lt[lef].t=lt[u].t-lt[rig].t;
        }
        else if(lt[u].op<0)/*升序*/{
            lt[u].op=0;lt[lef].op=lt[rig].op=-1;
            lt[lef].t=min(lt[u].t,lt[lef].r-lt[lef].l+1);
            lt[rig].t=lt[u].t-lt[lef].t;
        }
        if(b[i].l<=mid) cover(lef,i);
        if(b[i].r>mid) cover(rig,i);
        lt[u].t=lt[lef].t+lt[rig].t;
    }
}
inline int ask(int u,int l,int r){
    if(lt[u].l>=l&&lt[u].r<=r)
        return lt[u].t;
    if(lt[u].l<lt[u].r){
        int lef=u<<1,rig=u<<1|1,ret=0;
        int mid=(lt[u].l+lt[u].r)>>1;
        if(lt[u].op>0)/*降序*/{
            lt[u].op=0;lt[lef].op=lt[rig].op=1;
            lt[rig].t=min(lt[u].t,lt[rig].r-lt[rig].l+1);
            lt[lef].t=lt[u].t-lt[rig].t;
        }
        else if(lt[u].op<0)/*升序*/{
            lt[u].op=0;lt[lef].op=lt[rig].op=-1;
            lt[lef].t=min(lt[u].t,lt[lef].r-lt[lef].l+1);
            lt[rig].t=lt[u].t-lt[lef].t;
        }
        if(l<=mid) ret+=ask(lef,l,r);
        if(r>mid) ret+=ask(rig,l,r);
        return ret;
    }
}
inline bool chk(int k){
    build(1,1,n,k);
    for(int i=1;i<=m;++i){
        t=ask(1,b[i].l,b[i].r);cover(1,i);
    }
    return !ask(1,q,q);
}
inline void init(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;++i)
        scanf("%d",&a[i]);
    for(int i=1;i<=m;++i)
        scanf("%d%d%d",&b[i].op,&b[i].l,&b[i].r);
    scanf("%d",&q);
    l=1;r=n;
    while(l<r){
        mid=(l+r+1)>>1;
        if(chk(mid)) l=mid;
        else r=mid-1;
    } 
    printf("%d\n",l);
}
int main(){
    freopen("sort.in","r",stdin);
    freopen("sort.out","w",stdout);
    init();
    fclose(stdin);
    fclose(stdout);
    return 0;
}