主席树

作用

主席树（ChairTree?）全名貌似叫函数式线段树，利用了可持久化的思想从而使得主席树可以快速查询区间第k大，但是美中不足的是，主席树是个离线算法，不能像线段树，平衡树那样在线。

实现

给出一个序列a，编号为1~n，如果用线段树实现1~n中的第k大，我们可以这样：将a离散（就是因为要离散，所以并不能在线），假设去重之后有a[0]个元素。先构造一棵1~a[0]的线段树，每个线段储存这个区间内的总个数，然后从根节点开始，如果k<=左儿子的总个数，那么就向左儿子继续查找，否则k减去左儿子的总个数，然后向右儿子查找（和平衡树类似）。

如果询问任意区间L~R就不能用上述方法处理了，但是上述方法给了我们重要启示。于是我们想到，对于每个前缀1~i，构造一棵1~a[0]的线段树，这样的话每棵线段树就一模一样了，从而能进行“减法”。根据容斥原理，要求L~R，我们就可以先用1~R的线段树减去1~L-1的线段树得到一棵新线段树（当然实际实现时并不用真的构造这棵新线段树），在新线段树上进行之前的查找第k大即可！

空间问题

然而不知道读者有没有发现，这样搞空间很大啊！n棵线段树，每棵线段树2*n个节点（这里说2*n而不是4*n是因为主席树需要用记录左右儿子的方法储存线段树，而不是用常用的2*x和2*x+1来储存线段树），空间复杂度为O(2*n^2)，n一大就华丽丽的MLE。而文章开头提到了可持久化，却毛都没讲。没错，可持久化就是为了解决空间问题而存在的。假设我们构建好了1~i-1的线段树，其实1~i的线段树完全可以“借助”1~i-1的线段树来构造，如图：

第1棵线段树需要插入2，那么只需要重建红色的几个节点，其他节点都可以从第0棵线段树那里获得，后面的构造同理。这就是可持续化，储存前面的状态，利用前面和后面状态的共同性来减少空间甚至时间开销。

模板

#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn=100000,maxt=2000000;

int n,te,a[maxn+5],b[maxn+5];
//==========================================================
struct Node
{
    Node *son[2];
    int L,R,sum;
    void Pushup() {sum=son[0]->sum+son[1]->sum;}
};
typedef Node* P_node;
Node tem[maxt+5];
P_node null=tem,len=null,ro[maxn+5];
P_node newNode(int L,int R,int sum)
{
    len++;len->son[0]=len->son[1]=null;
    len->L=L;len->R=R;len->sum=sum;
    return len;
}
P_node Build(int L,int R)
{
    P_node now=newNode(L,R,0);
    if (L==R) return now;
    int mid=L+(R-L>>1);
    now->son[0]=Build(L,mid);now->son[1]=Build(mid+1,R);
    now->Pushup();
    return now;
}
P_node Insert(P_node lst,int x) //插入，lst是上一状态
{
    P_node now=newNode(lst->L,lst->R,lst->sum);
    now->son[0]=lst->son[0];now->son[1]=lst->son[1];
    //该节点需要重建
    if (now->L==now->R) {now->sum++;return now;} //边界
    int mid=now->L+(now->R-now->L>>1);
    if (x<=mid) now->son[0]=Insert(now->son[0],x); else
    now->son[1]=Insert(now->son[1],x);
    now->Pushup();
    return now;
}
int Askkth(P_node l,P_node r,int k) //询问l~r的第k大
{
    if (l->L==l->R) return b[l->L];
    int now=r->son[0]->sum-l->son[0]->sum;
    if (k<=now) return Askkth(l->son[0],r->son[0],k); else
    return Askkth(l->son[1],r->son[1],k-now);
}
//==========================================================
bool Eoln(char ch) {return ch==10||ch==13||ch==EOF;}
int readi(int &x) //int读入优化
{
    int tot=0,f=1;char ch=getchar(),lst=' ';
    while ('9'<ch||ch<'0') {if (ch==EOF) return EOF;lst=ch;ch=getchar();}
    if (lst=='-') f=-f;
    while ('0'<=ch&&ch<='9') tot=tot*10+ch-48,ch=getchar();
    x=tot*f;
    return Eoln(ch);
}
int Find(int x)
{
    int L=1,R=b[0];
    while (L<=R)
    {
        int mid=L+(R-L>>1);
        if (x==b[mid]) return mid;
        if (x<b[mid]) R=mid-1; else L=mid+1;
    }
}
int main()
{
    freopen("ChairTree.in","r",stdin);
    freopen("ChairTree.out","w",stdout);
    readi(n);readi(te);
    for (int i=1;i<=n;i++) readi(a[i]),b[i]=a[i];
    sort(b+1,b+1+n);
    b[0]=1;for (int i=2;i<=n;i++) if (b[i]>b[i-1]) b[++b[0]]=b[i];
    //离散
    ro[0]=Build(1,b[0]);
    for (int i=1;i<=n;i++) ro[i]=Insert(ro[i-1],Find(a[i]));
    while (te--)
    {
        int x,y,z;readi(x);readi(y);readi(z);
        printf("%d\n",Askkth(ro[x-1],ro[y],z));
    }
    return 0;
}