ZOJ 2112 Dynamic Rankings（树状数组套主席树）

题意就是带修改的区间第K大，看了诸多大牛的博客才弄懂。

首先静态的主席树就是多个线段树，只不过加一个数进去只需要修改log(n)个点，所以就可知历史版本。树中每个点值是个前缀和

修改的话因为树中每个点都是前缀和，修改这个数的话，后面每个树的这个数都要改，所以就要用到树状数组，想想树状数组，修改的时候只用修改logn个点，那么放在这里就只要修改logn个线段树，其他做法都是类似的，具体还是要看下代码实现才容易理解。

但是zoj的限制内存太厉害，因为一次修改根据树状数组是logn个，每个要加logn个点，所以每次修改一个点就要加log^2n个点，如果先全加n，那么空间复杂度是(n+m)log^2n，我们注意到n有50000，但是m只有10000，所以可以对于原序列建主席树，按照静态的做法，修改的话是去树状数组里logn个线段树修改，这样查询的时候是树状数组这个区间加上原序列的这个区间，所以空间复杂度降到nlogn+mlog^2n。

AC代码：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<string>
#include<cmath>
#include<string>
#include<string.h>
#include<vector>
#include<map>
#include<queue>
#include<cstdlib>
using namespace std;
#define ll long long
#define MOD 1000000007
#define IDX(l,r) ((l)+(r) | (l)!=(r))
//#define lson l,mid
//#define rson mid+1,r
const int maxn = 50000+10;
//const int maxm = 2600010;
const int maxm = 10010*16*16;
int lson[maxm],rson[maxm],T[maxm];
int root[maxn],use[maxn],yroot[maxn];
int nodecnt,n,nct;
int build(int l, int r)
{
int rt = nodecnt++;
T[rt] = 0;
if(l == r) return rt;
int mid = (l+r)>>1;
lson[rt] = build(l,mid);
rson[rt] = build(mid+1,r);
return rt;
}

int update(int pos, int v, int prert)
{
int newrt = nodecnt++,tmp = newrt;
int l = 1,r = nct;
T[newrt] = T[prert]+v;
while(l < r)
{
int mid = (l+r)>>1;
if(pos <= mid)
{
lson[newrt] = nodecnt++; rson[newrt] = rson[prert];
T[lson[newrt]] = T[lson[prert]]+v;
newrt = lson[newrt]; prert = lson[prert];
r = mid;
}
else
{
rson[newrt] = nodecnt++; lson[newrt] = lson[prert];
T[rson[newrt]] = T[rson[prert]]+v;
newrt = rson[newrt]; prert = rson[prert];
l = mid+1;
}
}
return tmp;
}

inline int lowbit(int x)
{
return x&(-x);
}

void add(int x, int pos,int v)
{
while(x <= n)
{
root[x] = update(pos,v,root[x]);
x += lowbit(x);
}
}

int sum(int x)
{
int ret = 0;
while(x)
{
ret += T[lson[use[x]]];
x -= lowbit(x);
}
return ret;
}

int query(int L, int R, int k)
{
for(int i = L-1; i ; i -= lowbit(i)) use[i] = root[i];
for(int i = R; i ; i -= lowbit(i)) use[i] = root[i];
int l = 1,r = nct,leftrt = yroot[L-1],rightrt = yroot[R];
while(l < r)
{
int mid = (l+r)>>1;
int tmp = sum(R)-sum(L-1)+T[lson[rightrt]]-T[lson[leftrt]];
// cout<<"what"<<tmp<<" "<<k<<" "<<sum(R)<<" "<<sum(L-1)<<" "<<l<<" "<<r<<endl;
if(tmp >= k)
{
for(int i = L-1; i ; i -= lowbit(i)) use[i] = lson[use[i]];
for(int i = R; i ; i -= lowbit(i)) use[i] = lson[use[i]];
rightrt = lson[rightrt]; leftrt = lson[leftrt];
r = mid;
}
else
{
k -= tmp;
for(int i = L-1; i ; i -= lowbit(i)) use[i] = rson[use[i]];
for(int i = R; i ; i -= lowbit(i)) use[i] = rson[use[i]];
rightrt = rson[rightrt]; leftrt = rson[leftrt];
l = mid+1;
}
}
return l;
}

struct query
{
int flag,l,r,k;
}q[10005];

int a[maxn],b[maxn+10005];

int getpos(int x)
{
return lower_bound(b+1,b+1+nct,x)-b;
}

int main()
{
#ifdef GLQ
freopen("input.txt","r",stdin);
// freopen("o.txt","w",stdout);
#endif
int t,m;
scanf("%d",&t);
while(~scanf("%d%d",&n,&m))
{
nodecnt = 0;
int tmp = n+1;
for(int i = 1; i <= n; i++)
{
scanf("%d",&a[i]);
b[i] = a[i];
}
for(int i = 1; i <= m; i++)
{
char s[2];
scanf("%s",s);
if(s[0] == 'Q')
{
q[i].flag = 0;
scanf("%d%d%d",&q[i].l,&q[i].r,&q[i].k);
}
else
{
q[i].flag = 1;
scanf("%d%d",&q[i].l,&q[i].k);
b[tmp++] = q[i].k;
}
}
sort(b+1,b+tmp);
nct = unique(b+1,b+tmp)-(b+1);
yroot[0] = build(1,nct);
for(int i = 1; i <= n; i++)
{
int pos = getpos(a[i]);
yroot[i] = update(pos,1,yroot[i-1]);
// add(i,pos,1);
}
memset(root,0,sizeof(root));
for(int i = 1; i <= m; i++)
{
if(q[i].flag == 0)
{
printf("%d\n",b[query(q[i].l,q[i].r,q[i].k)]);
}
else
{
int pos1 = getpos(a[q[i].l]), pos2 = getpos(q[i].k);
add(q[i].l,pos1,-1);
add(q[i].l,pos2,1);
a[q[i].l] = q[i].k;
}
}
}
return 0;
}