主席树相关

裸主席树：

#include<bits/stdc++.h>
#define maxn 1008611
#define maxm 10086
using namespace std;

template<size_t SIZE>
struct MemoryPool{
    char buf[SIZE],*cur;
    
    MemoryPool():cur(buf){}
    
    inline void *alloc(const int size){
        if(cur==buf+SIZE) return malloc(size);
        else{
            char *p=cur;
            cur+=size;
            return p;
        }
    }
};

MemoryPool<(4+4+8+8+4)*maxn*10> pool;

struct Chairman_Tree{
    struct Node{
        int l,r;
        Node *lc,*rc;
        int cnt;
        
        Node(const int l,const int r,Node *lc=NULL,Node *rc=NULL):l(l),r(r),lc(lc),rc(rc),cnt((lc?lc->cnt:0)+(rc?rc->cnt:0)){};
        Node(const int l,const int r,const int cnt):l(l),r(r),lc(NULL),rc(NULL),cnt(cnt){};
        
        inline void pushdown(){
            if(lc&&rc) return ;
            
            const int mid=(l+r)>>1;
            if(!lc) lc=new (pool.alloc(sizeof(Node))) Node(l,mid);
            if(!rc) rc=new (pool.alloc(sizeof(Node))) Node(mid+1,r);
        }
        
        Node *insert(const int val){
            if(val<l||val>r) return this;
            else if(val==l&&val==r) return new (pool.alloc(sizeof(Node))) Node(l,r,this->cnt+1);
            else{
                const int mid=(l+r)>>1;
                pushdown();
                if(val<=mid) return new (pool.alloc(sizeof(Node))) Node(l,r,lc->insert(val),rc);
                else return new (pool.alloc(sizeof(Node))) Node(l,r,lc,rc->insert(val));
            }
        }
        
        inline int rank() const {
            return lc?lc->cnt:0;
        } 
    }*root[maxn+1];
    
    int n;
    
    void build(const int a[],const int n){
        this->n=n;
        root[0]=new (pool.alloc(sizeof(Node))) Node(0,n-1);
        for(int i=1;i<=n;++i) root[i]=root[i-1]->insert(a[i-1]);
    }
    
    int query(const int l,const int r,int k){
        Node *L=root[l-1],*R=root[r];
        int min=0,max=n-1;
        while(min!=max){
            L->pushdown(),R->pushdown();
            int mid=(max+min)>>1,t=R->rank()-L->rank();
            if(k<=t) L=L->lc,R=R->lc,max=mid;
            else k-=t,L=L->rc,R=R->rc,min=mid+1;
        }
        return min;
    }
}t;

int n, m, a[maxn];

int main() {
    scanf("%d %d", &n, &m);
    for (int i = 0; i < n; i++) scanf("%d", &a[i]);

    static int set[maxn];
    copy(a, a + n, set);
    sort(set, set + n);
    int *end = unique(set, set + n);
    for (int i = 0; i < n; i++) a[i] = lower_bound(set, end, a[i]) - set;

    t.build(a, n);

    for (int i = 0; i < m; i++) {
        int l, r, k;
        scanf("%d %d %d", &l, &r, &k);
        int ans = t.query(l, r, k);
        printf("%d
", set[ans]);
    }

    return 0;
}

可持久化数组：

#include<cstdio>
#define MAXN 1000005

int base[MAXN];

template<typename T,size_t maxn>
struct Chairman_Tree{
    enum Relation{
        L=0,R=1
    };
    
    int root[maxn];
    int ch[maxn][2];
    T val[maxn];
    int index=0;
    
    inline void build(int &o,const T a[],const int &l,const int &r){
        o=++index;
        
        if(l==r){
            val[o]=a[l];
            return;
        }
        
        const int mid=(l+r)>>1;
        build(ch[o][L],a,l,mid);
        build(ch[o][R],a,mid+1,r);
    }
    
    inline void modify(int &o,const int &pre,const int &l,const int &r,const int &k,const T &v){
        o=++index;
        
        ch[o][L]=ch[pre][L],ch[o][R]=ch[pre][R],val[o]=val[pre];
        
        if(l==r){
            val[o]=v;
            return;
        }
        const int mid=(l+r)>>1;
        if(k<=mid) modify(ch[o][L],ch[pre][L],l,mid,k,v);
        else modify(ch[o][R],ch[pre][R],mid+1,r,k,v);
    }
    
    inline int query(const int &o,const int &l,const int &r,const int &k){
        if(l==r) return val[o];
        const int mid=(l+r)>>1;
        if(k<=mid) return query(ch[o][L],l,mid,k);
        else return query(ch[o][R],mid+1,r,k);
    }
};

Chairman_Tree<int,MAXN*20> CT;

int main(){
    register int n,m;
    scanf("%d%d",&n,&m);
    
    for(register int i=1;i<=n;++i) scanf("%d",&base[i]);
    CT.build(CT.root[0],base,1,n);
    
    register int pre,opt,x,y;
    for(register int i=1;i<=m;++i){
        scanf("%d%d%d",&pre,&opt,&x);
        if(opt==1){
            scanf("%d",&y);
            CT.modify(CT.root[i],CT.root[pre],1,n,x,y);
        }else{
            printf("%d
",CT.query(CT.root[pre],1,n,x));
            CT.root[i]=CT.root[pre];
        }
    }
    return 0;
}

主席树统计区间数种数：

#pragma G++ optimize (2)
#include<cstdio>
#include<map>
#define N 100001

template<typename T>
inline void read(T &x){
  char ch;while((ch=getchar()),(ch>'9'||ch<'0'));
  x=ch-'0';while((ch=getchar()),(ch>='0'&&ch<='9')) x=x*10+ch-'0';
}

template<size_t maxn>
struct Chairman_Tree{
    enum Relation{
        L=0,R=1
    };
    
    int root[maxn*20],index;
    int ch[maxn*20][2],val[maxn*20];
    
    Chairman_Tree():index(0){
        //memset(root,0,sizeof root);
        //memset(ch,0,sizeof ch);
        //memset(val,0,sizeof val);
    }
    
    inline void pushup(const int &o){
        val[o]=val[ch[o][L]]+val[ch[o][R]];
    }
    
    int build(const int &l,const int &r){
        int o=index++;
        
        if(l==r){
            val[o]=0;
            return o;
        }
        
        const int mid=(l+r)>>1;
        ch[o][L]=build(l,mid);
        ch[o][R]=build(mid+1,r);
        
        return o;
    }
    
    int update(const int pre,const int &l,const int &r,const int &pos,const int &v){
        int o=index++;
        
        ch[o][L]=ch[pre][L],ch[o][R]=ch[pre][R];
        val[o]=val[pre];
        
        if(l==pos&&r==pos){
            val[o]+=v;
            return o;
        }
        
        const int mid=(l+r)>>1;
        if(pos<=mid) ch[o][L]=update(ch[pre][L],l,mid,pos,v);
        else ch[o][R]=update(ch[pre][R],mid+1,r,pos,v);
        
        pushup(o);
        return o;
    }
    
    int query(const int &o,const int &l,const int &r,const int &pos){
        if(l==r) return val[o];
        
        const int mid=(l+r)>>1;
        if(pos<=mid) return val[ch[o][R]]+query(ch[o][L],l,mid,pos);
        else return query(ch[o][R],mid+1,r,pos);
    }
};

Chairman_Tree<N> CT;
std::map<int,int> mp;
int b[N];

int main(){
    register int n,m,x,y;
    read(n);
    
    for(register int i=1;i<=n;++i) read(b[i]);
    CT.root[0]=CT.build(1,n);
    
    for(register int i=1;i<=n;++i){
        if(mp.find(b[i])==mp.end())
            CT.root[i]=CT.update(CT.root[i-1],1,n,i,1);
        else{
            int tmp=CT.update(CT.root[i-1],1,n,mp[b[i]],-1);
            CT.root[i]=CT.update(tmp,1,n,i,1);
        }
        mp[b[i]]=i;
    }
    
    read(m);
    for(register int i=0;i<m;++i){
        read(x),read(y);
        printf("%d
",CT.query(CT.root[y],1,n,x));
    }
}

树状数组套主席树（可修改主席树）：

#include<cstdio>
#include<algorithm>

#define lowbit(x) (x&-x)
#define N 10005

int n,m;
int a[N],b[N<<1|1];

template<size_t maxn>
struct Modifiable_CT{
    enum Realtion{
        L=0,R=1
    };
    
    int sz,totx,toty,totn;
    int root[maxn];
    int xx[maxn],yy[maxn];
    int ch[maxn*600][2],size[maxn*600];
    
    void ins(int &o,const int &l,const int &r,const int pre,const int &k,const int &v){
        o=++sz;
        
        size[o]=size[pre]+v;
        ch[o][L]=ch[pre][L],ch[o][R]=ch[pre][R];
        
        if(l==r) return;
        const int mid=(l+r)>>1;
        if(k<=mid) ins(ch[o][L],l,mid,ch[pre][L],k,v);
        else ins(ch[o][R],mid+1,r,ch[pre][R],k,v);
    }
    
    void modify(const int &x,const int &v){
        int k=std::lower_bound(b+1,b+totn+1,a[x])-b;
        for(int i=x;i<=n;i+=lowbit(i)) ins(root[i],1,totn,root[i],k,v);
    }
    
    int query(const int &l,const int &r,const int &k){
        if(l==r) return l;
        
        int sum=0;
        const int mid=(l+r)>>1;
        
        for(int i=1;i<=totx;++i) sum-=size[ch[xx[i]][L]];
        for(int i=1;i<=toty;++i) sum+=size[ch[yy[i]][L]];
        
        if(k<=sum){
            for(int i=1;i<=totx;++i) xx[i]=ch[xx[i]][L];
            for(int i=1;i<=toty;++i) yy[i]=ch[yy[i]][L];
            return query(l,mid,k);
        }else{
            for(int i=1;i<=totx;++i) xx[i]=ch[xx[i]][R];
            for(int i=1;i<=toty;++i) yy[i]=ch[yy[i]][R];
            return query(mid+1,r,k-sum);
        }
    }
};

Modifiable_CT<N> MCT;



int ca[N],cb[N],cc[N];
inline int read(){
    int f=1,x=0;char ch;
    do{ch=getchar();if(ch=='-')f=-1;}while(ch<'0'||ch>'9');
    do{x=x*10+ch-'0';ch=getchar();}while(ch>='0'&&ch<='9');
    return f*x;
}

int main(){
    register char s[20];
    n=read();m=read();
    for(register int i=1;i<=n;i++)a[i]=read(),b[++MCT.totn]=a[i];
    for(register int i=1;i<=m;i++){
        scanf("%s",s);ca[i]=read();cb[i]=read();
        if(s[0]=='Q')cc[i]=read();else b[++MCT.totn]=cb[i];
    }
    std::sort(b+1,b+MCT.totn+1);
    MCT.totn=std::unique(b+1,b+MCT.totn+1)-b-1;
    for(register int i=1;i<=n;i++) MCT.modify(i,1);
    for(register int i=1;i<=m;i++){
        if(cc[i]){
            MCT.totx=MCT.toty=0;
            for(register int j=ca[i]-1;j;j-=lowbit(j))MCT.xx[++MCT.totx]=MCT.root[j];
            for(register int j=cb[i];j;j-=lowbit(j))MCT.yy[++MCT.toty]=MCT.root[j];
            printf("%d
",b[MCT.query(1,MCT.totn,cc[i])]);
        }
        else{MCT.modify(ca[i],-1);a[ca[i]]=cb[i];MCT.modify(ca[i],1);}
    }
}