【BZOJ】【1901】【Zju2112】 Dynamic Rankings

再填个坑。

　动态维护区间第K大（带单点修改）

　　首先裸的区间第K大我们是用的【前缀和】思想，实现O(n)预处理，O(1)找树查询，那么如果是动态的呢？我们可以利用树状数组（BIT）的思想，进行O(logn)的修改，O(logn)的查询（当然由于是在线段树上做，都各需要再乘logn的复杂度）

　　也就是说，每次修改，一块改logn棵线段树；每次查询也是在logn棵线段树上一起往下找！

　　P.S.本题需将所有数（包括修改后的数）进行离散化

 //BZOJ 1901
 #include<cstdio>
 #include<cstring>
 #include<cstdlib>
 #include<iostream>
 #include<algorithm>
 #define rep(i,n) for(int i=0;i<n;++i)
 #define F(i,j,n) for(int i=j;i<=n;++i)
 #define D(i,j,n) for(int i=j;i>=n;--i)
 #define lowbit(x) ((x)&(-(x)))
 using namespace std;
 const int N=;

 struct Tree{
     int cnt,l,r;
 }t[N*];
 int n,m,num=,root[N],a[N>>],b[N],dat[N>>][],size=,cnt=;
 int lc,rc,ln[N],rn[N];

 #define mid (l+r>>1)
 void build(int &o,int l,int r){
     o=++cnt; t[o].cnt=;
     if (l==r) return;
     build(t[o].l,l,mid);
     build(t[o].r,mid+,r);
 }

 void updata(int &o,int l,int r,int pos,int val){
     t[++cnt]=t[o],o=cnt,t[o].cnt+=val;
     if (l==r) return;
     if (pos <= mid) updata(t[o].l,l,mid,pos,val);
     else updata(t[o].r,mid+,r,pos,val);
 }

 void modify(int x,int pos,int val){
     for(x;x<=n;x+=lowbit(x) )//一次改logn棵树
         updata(root[x],,num,pos,val);
 }

 int query(int i,int j,int rank){
     int l=,r=num;
     int tl=,tr=;

     while(l!=r){
         tl=tr=;
         F(i,,lc) tl+=t[t[ln[i]].l].cnt;//将logn棵树的和加出来
         F(i,,rc) tr+=t[t[rn[i]].l].cnt;
         if (tr-tl>=rank){
             F(i,,lc) ln[i]=t[ln[i]].l;//向左找
             F(i,,rc) rn[i]=t[rn[i]].l;
             r=mid;
         }
         else{
             F(i,,lc) ln[i]=t[ln[i]].r;//向右找
             F(i,,rc) rn[i]=t[rn[i]].r;
             l=mid+; rank-=tr-tl;
         }

     }
     return l;
 }
 #undef mid
 int getans(int l,int r,int k){
     rc=lc=;
     for(r;r;r-=lowbit(r))
         rn[++rc]=root[r];
     for(l;l;l-=lowbit(l))
         ln[++lc]=root[l];
     return query(,num,k);
 }

 void solve(){
     sort(b+,b+size+);
     num=unique(b+,b+size+)-b-;//这个神奇的用法……是什么意思？
     F(i,,n) a[i]=lower_bound(b+,b+num+,a[i])-b;
     build(root[],,num);
     F(i,,n) modify(i,a[i],);
     F(i,,m){
         if(dat[i][]==) printf("%d\n",b[ getans(dat[i][]-,dat[i][],dat[i][]) ]);
         else{
             int pos=lower_bound(b+,b+num+,dat[i][])-b;
             modify(dat[i][],a[dat[i][]],-);
             a[dat[i][]]=pos;
             modify(dat[i][],a[dat[i][]],);
         }
     }
 }

 int main(){
     #ifndef ONLINE_JUDGE
     freopen("file.in","r",stdin);
     #endif
     int T=;
 //    scanf("%d",&T);
     while(T--){
         size=cnt=num=;
         memset(b,,sizeof b);
         memset(t,,sizeof t);
         memset(dat,,sizeof dat);
         scanf("%d%d",&n,&m);
         F(i,,n){
             scanf("%d",&a[i]);
             b[++size]=a[i];
         }
         char cmd[];
         F(i,,m){
             scanf("%s",cmd);
             if (cmd[]=='C'){
                 dat[i][]=;
                 scanf("%d%d",&dat[i][],&dat[i][]);
                 b[++size]=dat[i][];
             }
             else{
                 dat[i][]=;
                 scanf("%d%d%d",&dat[i][],&dat[i][],&dat[i][]);
             }
         }
         solve();
     }
     return ;
 }
 /**************************************************
 利用BIT的思想，实现前缀-差分的logn的转化
 裸的可持久化线段树是每棵树维护一个区间[1,i](前缀和)
 查询O(1),而修改就需要 O(n)了
 而动态进行修改&查询-->BIT里套一个可持久化线段树
 BIT的每个节点表示原数组的一个区间
 然后用可持久化线段树来维护这个区间
 查询的时候log(n)棵线段树一起查
 **************************************************/