[主席樹]ZOJ2112 && BZOJ1901 Dynamic Rankings

題意：n個數，q個詢問 (n<=50000, q<=10000)

Q x y z 代表詢問[x, y]區間里的第z小的數

C x y    代表將(從左往右數)第x個數變成y

 

上篇介紹了在[x, y]區間內查詢第z小的數的方法(靜態主席樹)

本題有更新操作

 

若仍用上篇的做法，

每次更新一個數，需要更新的是T[i], T[i+1]... ...T[n](該數所在的樹以及它后面的所有樹)

因為每棵樹T[i]所記錄的都是前綴(1到i的數出現的次數) 因此，改變i，會影響i到n的所有樹

這樣，每次更新的復雜度最壞為O($n$)，最壞更新q次即為O($n\times m$) 復雜度相當龐大，很明顯這樣做是不行的

 

那怎么辦呢？

我們可以發現，對於改變i處的數這個操作，對於T[i], T[i+1]... ...T[n]這些樹的影響是相同的

  都只改變了  “原來i處的數 的數量”  和  “現在i處的數 的數量” 這兩個值而已

我們只要在原來的基礎上增加一類樹， 用它們來維護更新掉的數

即用樹狀數組來記錄更新，每次更新$logn$棵樹

 

下面來演示一下建樹到查詢的過程：

比如此題的第一個案例

5 3
3 2 1 4 7
Q 1 4 3
C 2 6
Q 2 5 3

先將序列以及要更新的數(C操作)離散化  

即3 2 1 4 7 、 6  ---->(排序) ----> 1 2 3 4 6 7  

那么我們就需要建一棵這樣的樹：

(圈里的都是結點的編號， 4、5、6、9、10、11號結點代表的分別是1、2、3、4、6、7)

(4、5、9、10你也可以任意作為6或11的兒子， 遞歸生成的是類似這樣的， 這並不重要)

 

對於3 2 1 4 7(先不管需要更新的6)建完樹見下圖(建樹過程同靜態的，不明白的戳這里，上篇博客有講)

(紅色的是個數， 相同結點的個數省略了，同前一棵樹)

 

對於C操作之前的Q，就跟靜態的類似，減一減 找就好了

 

然后下面要更新了

對於更新， 我們不改變這些已經建好的樹， 而是另建一批樹S，用來記錄更新，而這批線段樹，我們用樹狀數組來維護

也就是樹狀數組的每個節點都是一顆線段樹

一開始，S[0]、S[1]、S[2]、S[3]、S[4]、S[5](樹狀數組的每個節點)這些都與T[0]相同(也就是每個節點建了一棵空樹)

對於C 2 6 這個操作， 我們只需要減去一個2，加上一個6即可

對於減去2

(樹狀數組i+lowbit(i)為i的父親節點， 修改i，就要把i的所有父親節點都修改了)

2在樹狀數組中出現的位置是 2、2+lowbit(2)=4 這兩個位置，    

因此要更新的是S[2]和S[4]這兩個節點中的樹

刪去2后是這樣

加上一個6 (同樣是對於2號位置， 因此需要更新的仍是S[2]和S[4])

加上之后是這樣

 

 

 當查詢的時候， 對樹T的操作與靜態的一致，另外再加上S樹的值就好了

 

 

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
#define lson l, m
#define rson m+1, r
const int N=60005;
int a[N], Hash[N];
int T[N], L[N<<5], R[N<<5], sum[N<<5];
int S[N];
int n, m, tot;
struct node
{
    int l, r, k;
    bool Q;
}op[10005];

int build(int l, int r)
{
    int rt=(++tot);
    sum[rt]=0;
    if(l!=r)
    {
        int m=(l+r)>>1;
        L[rt]=build(lson);
        R[rt]=build(rson);
    }
    return rt;
}

int update(int pre, int l, int r, int x, int val)
{
    int rt=(++tot);
    L[rt]=L[pre], R[rt]=R[pre], sum[rt]=sum[pre]+val;
    if(l<r)
    {
        int m=(l+r)>>1;
        if(x<=m)
            L[rt]=update(L[pre], lson, x, val);
        else
            R[rt]=update(R[pre], rson, x, val);
    }
    return rt;
}

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

int use[N];
void add(int x, int pos, int val)
{
    while(x<=n)
    {
        S[x]=update(S[x], 1, m, pos, val);
        x+=lowbit(x);
    }
}

int Sum(int x)
{
    int ret=0;
    while(x>0)
    {
        ret+=sum[L[use[x]]];
        x-=lowbit(x);
    }
    return ret;
}

int query(int u, int v, int lr, int rr, int l, int r, int k)
{
    if(l>=r)
        return l;
    int m=(l+r)>>1;
    int tmp=Sum(v)-Sum(u)+sum[L[rr]]-sum[L[lr]];
    if(tmp>=k)
    {
        for(int i=u;i;i-=lowbit(i))
            use[i]=L[use[i]];
        for(int i=v;i;i-=lowbit(i))
            use[i]=L[use[i]];
        return query(u, v, L[lr], L[rr], lson, k);
    }
    else
    {
        for(int i=u;i;i-=lowbit(i))
            use[i]=R[use[i]];
        for(int i=v;i;i-=lowbit(i))
            use[i]=R[use[i]];
        return query(u, v, R[lr], R[rr], rson, k-tmp);
    }
}

void modify(int x, int p, int d)
{
    while(x<=n)
    {
        S[x]=update(S[x], 1, m, p, d);
        x+=lowbit(x);
    }
}

int main()
{
    int t;
    scanf("%d", &t);
    while(t--)
    {
        int q;
        scanf("%d%d", &n, &q);
        tot=0;
        m=0;
        for(int i=1;i<=n;i++)
        {
            scanf("%d", &a[i]);
            Hash[++m]=a[i];
        }
        for(int i=0;i<q;i++)
        {
            char s[10];
            scanf("%s", s);
            if(s[0]=='Q')
            {
                scanf("%d%d%d", &op[i].l, &op[i].r, &op[i].k);
                op[i].Q=1;
            }
            else
            {
                scanf("%d%d", &op[i].l, &op[i].r);
                op[i].Q=0;
                Hash[++m]=op[i].r;
            }
        }
        sort(Hash+1, Hash+1+m);
        int mm=unique(Hash+1, Hash+1+m)-Hash-1;
        m=mm;
        T[0]=build(1, m);
        for(int i=1;i<=n;i++)
            T[i]=update(T[i-1], 1, m, lower_bound(Hash+1, Hash+1+m, a[i])-Hash, 1);
        for(int i=1;i<=n;i++)
            S[i]=T[0];
        for(int i=0;i<q;i++)
        {
            if(op[i].Q)
            {
                for(int j=op[i].l-1;j;j-=lowbit(j))
                    use[j]=S[j];
                for(int j=op[i].r;j;j-=lowbit(j))
                    use[j]=S[j];
                printf("%d\n", Hash[query(op[i].l-1, op[i].r, T[op[i].l-1], T[op[i].r], 1, m, op[i].k)]);
            }
            else
            {
                modify(op[i].l, lower_bound(Hash+1, Hash+1+m, a[op[i].l])-Hash, -1);
                modify(op[i].l, lower_bound(Hash+1, Hash+1+m, op[i].r)-Hash, 1);
                a[op[i].l]=op[i].r;
            }
        }
    }
    return 0;
}