主席树（可持久化线段树）入门专题

1.poj 2104 查询区间第k小。

主席树其实相当于建立了n棵线段树，第i棵线段树是根据区间【1，i】按值建立的。对于每一棵线段树我们记录它对应的区间每个数出现的次数，所以首先要对所有的数离散化。

先考虑最简单的情况，只查询【1，n】的第k小，对于【1，n】我们按值建立一棵线段树，对于a[i]我们在位置a[i]上加1。查询第k小那么先看左子区间出现了多少个数cnt，假设左区间出现的数cnt>=k，那么直接递归到左区间查询（因为是按值建立的，左区间的数肯定小于右区间），否则递归到右区间查询第k-cnt小（左区间已经有了最小的cnt个数了）

对于任意区间查询【l，r】,我们只需要比较第l-1棵线段树和第r棵线段树，【l，r】之间的数就是第r棵线段树相比于第l-1棵多出来的数。只需要对比两颗树同一个节点，对比到哪个数为止第r棵比第l-1棵刚好多出k个数。（先比较左区间cntr-cntl，cntr-cntl>=k，则递归到左区间，否则递归查询右区间k-cntr-cntl）

主席树就相当于n棵线段树，但是对比建立在【1，i】的线段树和【1，i+1】的线段树，只多出了一个值，也就是相当于单点更新他们之间只有logn个节点是不同的，所以可以将【1，i+1】的一些节点指针指向前一棵的共同部分。每次新增的空间只需要logn。

代码是根据kuangbin模板抄的。。。。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <cctype>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <vector>
#include <queue>
#include <stack>
#include <algorithm>
using namespace std;

const int maxn=1e5+10;
const int M=maxn*30;

int n,q,m,tot;
int a[maxn], t[maxn];
int T[maxn], lson[M], rson[M], c[M];

void init_hash()
{
    for(int i=1; i<=n; i++)
        t[i]=a[i];
    sort(t+1, t+n+1);
    m=unique(t+1, t+n+1)-t-1;
}

int hash(int x)
{
    return lower_bound(t+1, t+1+m, x)-t;
}

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


int update(int rt, int pos, int val)
{
    int newrt=tot++,tmp=newrt;
    c[newrt]=c[rt]+val;
    int l=1, r=m;
    while(l<r){
        int mid=(l+r)>>1;
        if(pos<=mid){
            lson[newrt]=tot++; rson[newrt]=rson[rt];
            newrt=lson[newrt]; rt=lson[rt];
            r=mid;
        }
        else{
            rson[newrt]=tot++; lson[newrt]=lson[rt];
            newrt=rson[newrt]; rt=rson[rt];
            l=mid+1;
        }
        c[newrt]=c[rt]+val;
    }
    return tmp;
}

int query(int lrt, int rrt, int k)
{
    int l=1, r=m;
    while(l<r){
        int mid=(l+r)>>1;
        if(c[lson[lrt]]-c[lson[rrt]]>=k){
            r=mid;
            lrt=lson[lrt];
            rrt=lson[rrt];
        }
        else{
            l=mid+1;
            k-=c[lson[lrt]]-c[lson[rrt]];
            lrt=rson[lrt];
            rrt=rson[rrt];
        }
    }

    return l;
}

int main()
{
    while(cin>>n>>q){
        
        for(int i=1; i<=n; i++)
            scanf("%d", a+i);
        init_hash();
        tot=0;
        T[n+1]=build(1,m);

        for(int i=n; i; i--){
            int pos=hash(a[i]);
            T[i]=update(T[i+1], pos, 1);
        }
        while(q--){
            int l,r,k;
            scanf("%d%d%d", &l, &r, &k);
            printf("%d\n", t[query(T[l], T[r+1], k)]);
        }
    }
    return 0;
}

2.hdu 4417 区间查询<=H的数有多少个

查询【l，r】区间只需要将第r棵线段树【0，H】区间的总数减去第l-1棵的就行了。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <cctype>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <vector>
#include <queue>
#include <stack>
#include <algorithm>
using namespace std;
const int maxn=1e5+10;
const int maxm=maxn*30;

int n,m, N;
int a[maxn],b[2*maxn];
int T[maxn],tot;
int lson[maxm],rson[maxm], cnt[maxm];

int build(int l, int r)
{
    int rt=tot++;
    cnt[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 rt, int pos, int v)
{
    int newrt=tot++, ret=newrt;
    int l=1, r=N;
    cnt[newrt]=cnt[rt]+v;
    while(l<r){
        int mid=(l+r)>>1;
        if(pos<=mid){
            lson[newrt]=tot++; rson[newrt]=rson[rt];
            newrt=lson[newrt]; rt=lson[rt];
            r=mid;
        }
        else{
            lson[newrt]=lson[rt]; rson[newrt]=tot++;
            newrt=rson[newrt]; rt=rson[rt];
            l=mid+1;
        }
        cnt[newrt]=cnt[rt]+v;
    }

    return ret;
}


int query(int lrt, int rrt, int pos)
{
    int ret=0;
    int l=1,r=N;
    while(l<r){
        int mid=(l+r)>>1;
        if(pos<=mid){
            lrt=lson[lrt]; rrt=lson[rrt];
            r=mid;
        }
        else{
            ret+=cnt[lson[rrt]]-cnt[lson[lrt]];
            lrt=rson[lrt]; rrt=rson[rrt];
            l=mid+1;
        }
    }
    ret+=cnt[rrt]-cnt[lrt];
    return ret;
}


int l[maxn], r[maxn], h[maxn];
int main()
{
    int t;
    cin>>t;
    for(int tt=1; tt<=t; tt++){
        cin>>n>>m;
        for(int i=1; i<=n; i++){
            scanf("%d", a+i);
            b[i]=a[i];
        }

        for(int i=0; i<m; i++){
            scanf("%d%d%d", l+i, r+i, h+i);
            b[n+1+i]=h[i];
        }
        sort(b+1, b+1+n+m);
        N=unique(b+1, b+1+n+m)-b-1;

        tot=0;
        T[0]=build(1,N);
        for(int i=1; i<=n; i++){
            int v=lower_bound(b+1, b+1+N, a[i])-b;
            T[i]=update(T[i-1], v, 1);
        }

        printf("Case %d:\n", tt);
        for(int i=0; i<m; i++){
            int v=lower_bound(b+1, b+1+N, h[i])-b;
            printf("%d\n", query(T[l[i]], T[r[i]+1], v));
        }


    }
    return 0;
}

3.hdu 4348 可持久化线段树，区间更新，不下放的懒惰标记（空间优化）

主席树其实就是可持久化线段树。可持久化就是每次修改操作，尽量用新节点表示而不是直接修改原来的点，这样所有的历史版本都得以保留。

主要麻烦的就是区间更新。区间更新对于完全覆盖的区间要用lazy标记。但是每次lazy下放的时候两个子区间都发生修改需要创造两个新的节点，这样到最后下放到最后一层相当于消耗了O(n)个新节点，空间会爆。

这道题用的空间优化就是不下放标记。标记就打在那个区间节点上，而查询的时候，往下递归时遇到标记就累加，最后把标记的影响加到总答案里。这样就不需要创造那么多新节点了。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <cctype>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <vector>
#include <queue>
#include <stack>
#include <algorithm>
using namespace std;
const int maxn=1e5+1000;
const int maxm=30*maxn;
typedef long long LL;
int n, m;
int a[maxn];
int T[maxn], tot=0;
int lson[maxm],rson[maxm], lazy[maxm];
LL sum[maxm];

void push_up(int rt, int l, int r)
{
    sum[rt]=sum[lson[rt]]+sum[rson[rt]]+(LL)lazy[rt]*(r-l+1);
}


int build(int l, int r)
{
    int rt=tot++;
    lazy[rt]=0;
    if(l==r){
        sum[rt]=a[l];
        return rt;
    }

    int mid=(l+r)>>1;
    lson[rt]=build(l,mid);
    rson[rt]=build(mid+1, r);
    push_up(rt, l, r);
    return rt;
}

int update(int rt, int l, int r, int ll, int rr, int v)
{
    int newrt=tot++;
    lazy[newrt]=lazy[rt];
    if(ll<=l && r<=rr){
        lson[newrt]=lson[rt], rson[newrt]=rson[rt];
        lazy[newrt]=lazy[rt]+v;
        sum[newrt]=sum[rt]+(LL)v*(r-l+1);
        return newrt;
    }


    int mid=(l+r)>>1;
    if(rr<=mid){
        rson[newrt]=rson[rt];
        lson[newrt]=update(lson[rt], l, mid, ll, rr, v);
    }
    else if(ll>mid){
        lson[newrt]=lson[rt];
        rson[newrt]=update(rson[rt], mid+1, r,ll, rr, v);
    }
    else{
        lson[newrt]=update(lson[rt], l, mid, ll, mid, v);
        rson[newrt]=update(rson[rt], mid+1, r, mid+1, rr, v);
    }

    push_up(newrt, l, r);
    return newrt;
}


LL query(int rt, int l, int r, int ll, int rr, int  la)
{

    if(ll<=l && r<=rr){
        return sum[rt]+(LL)la*(r-l+1);
    }
    la+=lazy[rt];

    int mid=(l+r)>>1;
    if(rr<=mid)
        return query(lson[rt], l, mid, ll, rr, la);
    else if(ll>mid)
        return query(rson[rt], mid+1, r, ll, rr, la);
    else
        return query(lson[rt], l, mid, ll, mid, la)+query(rson[rt], mid+1, r, mid+1, rr, la);
}


int main()
{
    while(cin>>n>>m){
        for(int i=1; i<=n; i++)
            scanf("%d", a+i);

        tot=0;
        T[0]=build(1,n);
        int tag=0;
        while(m--){
            char s[5];
            int l,r,d;
            scanf("%s%d", s, &l);
            if(s[0]=='B'){
                tag=l;
            }
            else{
                scanf("%d", &r);
                if(s[0]=='Q'){
                    LL res=query(T[tag], 1, n, l, r, 0);
                    printf("%I64d\n", res);
                }
                else{
                    scanf("%d", &d);
                    if(s[0]=='C'){
                        tag++;
                        T[tag]=update(T[tag-1], 1, n, l, r, d);
                    }
                    else{
                        LL res=query(T[d], 1, n, l, r, 0);
                        printf("%I64d\n", res);
                    }
                }
            }
        }
    }
    return 0;
}