[BZOJ4552][TJOI2016&&HEOI2016]排序(二分答案+线段树/线段树分裂与合并)

解法一：二分答案+线段树

首先我们知道，对于一个01序列排序，用线段树维护的话可以做到单次排序复杂度仅为log级别。

这道题只有一个询问，所以离线没有意义，而一个询问让我们很自然的想到二分答案。先二分出这个位置上的数是多少，然后将所有小于等于的数全部赋为0，其余赋为1，这样每次排序都是01序列排序了。如果最后p位置上的数为0则说明最终答案小于等于当前二分的答案，反之亦然。

这样这个问题就在$O(n \log^2 n)$的复杂度内解决了。

 #include<cstdio>
 #include<algorithm>
 #define ls (x<<1)
 #define rs ((x<<1)|1)
 #define lson ls,L,mid
 #define rson rs,mid+1,R
 #define rep(i,l,r) for (int i=l; i<=r; i++)
 using namespace std;

 const int N=;
 int n,m,qry,a[N],c[N],sm[N<<],tag[N<<];
 struct P{ int op,l,r; }b[N];

 void push(int x,int L,int R){
     if (tag[x]==-) return;
     int mid=(L+R)>>;
     sm[ls]=(mid-L+)*tag[x]; tag[ls]=tag[x];
     sm[rs]=(R-mid)*tag[x]; tag[rs]=tag[x];
     tag[x]=-;
 }

 void build(int x,int L,int R){
     tag[x]=-;
     if (L==R) { sm[x]=c[L]; return; }
     int mid=(L+R)>>;
     build(lson); build(rson);
     sm[x]=sm[ls]+sm[rs];
 }

 void mdf(int x,int L,int R,int l,int r,int k){
     if (L==l && r==R){ sm[x]=k*(R-L+); tag[x]=k; return; }
     int mid=(L+R)>>; push(x,L,R);
     if (r<=mid) mdf(lson,l,r,k);
     else if (l>mid) mdf(rson,l,r,k);
         else mdf(lson,l,mid,k),mdf(rson,mid+,r,k);
     sm[x]=sm[ls]+sm[rs];
 }

 int que(int x,int L,int R,int l,int r){
     if (L==l && r==R) return sm[x];
     int mid=(L+R)>>; push(x,L,R);
     if (r<=mid) return que(lson,l,r);
     else if (l>mid) return que(rson,l,r);
         else return que(lson,l,mid)+que(rson,mid+,r);
 }

 int main(){
     scanf("%d%d",&n,&m);
     rep(i,,n) scanf("%d",&a[i]);
     rep(i,,m) scanf("%d%d%d",&b[i].op,&b[i].l,&b[i].r);
     scanf("%d",&qry);
     int L=,R=n;
     while (L<R){
         int mid=(L+R)>>;
         rep(i,,n) if (a[i]<=mid) c[i]=; else c[i]=;
         build(,,n);
         rep(i,,m){
             int l=b[i].l,r=b[i].r,s=que(,,n,l,r);
             if (b[i].op==){
                 if (l<=r-s) mdf(,,n,l,r-s,);
                 if (r-s+<=r) mdf(,,n,r-s+,r,);
             }else{
                 if (l<=l+s-) mdf(,,n,l,l+s-,);
                 if (l+s<=r) mdf(,,n,l+s,r,);
             }
         }
         if (que(,,n,qry,qry)==) R=mid; else L=mid+;
     }
     printf("%d\n",L);
     return ;
 }

解法二：线段树分裂与合并

对每个连续的有序区间维护一棵线段树（初始时每个点都有一棵线段树）。

每次将一个区间排序时，先将跨过这个区间端点的区间分裂，再将这个区间包含的所有小区间合并。

set维护区间，区间合并通过线段树合并实现，时间复杂度为$O(n\log n)$。

可以垃圾回收，由于每次分裂只会新增log n个点，加上初始时新建的点，空间复杂度为$O((n+m)\log n)$。

这个方法不仅复杂度只有一个log，还能在最后求出整个序列而不是单个序列。

 #include<set>
 #include<cstdio>
 #include<algorithm>
 #define lson ls[x],L,mid
 #define rson rs[x],mid+1,R
 #define rep(i,l,r) for (int i=(l); i<=(r); i++)
 using namespace std;

 const int N=,M=;
 int n,m,x,nd,op,l,r,top,rt[N],rev[N],stk[M],ls[M],rs[M],sz[M];
 struct P{ int l,r; };
 bool operator <(const P &a,const P &b){ return a.r<b.r; }
 set<P>S;

 void del(int x){ ls[x]=rs[x]=sz[x]=; stk[++top]=x; }
 int get(){ return top ? stk[top--] : ++nd; }

 void ins(int &x,int L,int R,int k){
     if (!x) x=get(); sz[x]++;
     if (L==R) return;
     int mid=(L+R)>>;
     if (k<=mid) ins(lson,k); else ins(rson,k);
 }

 void split(int &x,int &y,int k,int op){
     if (!x) return;
     sz[y=get()]=sz[x]-k; sz[x]=k;
     if (!op){
         if (sz[ls[x]]==k){ rs[y]=rs[x]; rs[x]=; return; }
         if (sz[ls[x]]>k){ rs[y]=rs[x]; rs[x]=; split(ls[x],ls[y],k,op); }
             else split(rs[x],rs[y],k-sz[ls[x]],op);
     }else{
         if (sz[rs[x]]==k){ ls[y]=ls[x]; ls[x]=; return; }
         if (sz[rs[x]]>k){ ls[y]=ls[x]; ls[x]=; split(rs[x],rs[y],k,op); }
             else split(ls[x],ls[y],k-sz[rs[x]],op);
     }
 }

 int merge(int x,int y){
     if (!x || !y) return x|y;
     sz[x]+=sz[y];
     ls[x]=merge(ls[x],ls[y]);
     rs[x]=merge(rs[x],rs[y]);
     del(y); return x;
 }

 int que(int x,int L,int R,int k,int op){
     if (L==R) return L;
     int mid=(L+R)>>;
     if (!op){
         if (sz[ls[x]]>=k) return que(lson,k,op); else return que(rson,k-sz[ls[x]],op);
     }else{
         if (sz[rs[x]]>=k) return que(rson,k,op); else return que(lson,k-sz[rs[x]],op);
     }
 }

 int main(){
     freopen("bzoj4552.in","r",stdin);
     freopen("bzoj4552.out","w",stdout);
     scanf("%d%d",&n,&m);
     rep(i,,n) scanf("%d",&x),ins(rt[i],,n,x),S.insert((P){i,i});
     while (m--){
         scanf("%d%d%d",&op,&l,&r);
         set<P>::iterator it=S.lower_bound((P){l,l});
         if (it->l<l){
             int L=it->l,R=it->r;
             split(rt[L],rt[l],l-L,rev[L]);
             S.erase(it); S.insert((P){L,l-}); S.insert((P){l,R});
             rev[l]=rev[L];
         }
         it=S.lower_bound((P){r+,r+});
         if (it!=S.end() && it->l<=r){
             int L=it->l,R=it->r;
             split(rt[L],rt[r+],r-L+,rev[L]);
             S.erase(it); S.insert((P){L,r}); S.insert((P){r+,R});
             rev[r+]=rev[L];
         }
         it=S.lower_bound((P){l,l}); it++;
         while (it!=S.end() && it->r<=r) rt[l]=merge(rt[l],rt[it->l]),it++;
         it=S.lower_bound((P){l,l});
         while (it!=S.end() && it->r<=r) S.erase(it),it=S.lower_bound((P){l,l});
         S.insert((P){l,r}); rev[l]=op;
     }
     scanf("%d",&x);
     set<P>::iterator it=S.lower_bound((P){x,x});
     printf("%d\n",que(rt[it->l],,n,x-(it->l)+,rev[it->l]));
     return ;
 }