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;
}