poj2104&&poj2761 静态区间查询第k大 主席树

主席树又叫函数式线段树，是以序列的每一个前缀建一棵以序列的值为下标的线段树，记录该前缀序列出现的值的次数。

令 T 表示一个结点，它的左儿子是 left(T)，右儿子是 right(T)。

若 T 的范围是 [L,R]，那么 left(T) 的范围是 [L,mid]，right(T) 的范围是 [mid+1,R]。

查询[1,n]中的第K小值

我们先对数据进行离散化，然后按值域建立线段树，线段树中维护某个值域中的元素个数。

在线段树的每个结点上用cnt记录这一个值域中的元素个数。

那么要寻找第K小值，从根结点开始处理，若左儿子中表示的元素个数大于等于K，那么我们递归的处理左儿子，寻找左儿子中第K小的数；

若左儿子中的元素个数小于K，那么第K小的数在右儿子中，我们寻找右儿子中第K-(左儿子中的元素数)小的数。

以1 5 2 6 3 7 4为例离散化后建立的线段树如图

区间存储对应数值的出现次数

查询区间[L,R]中的第K小值

我们按照从1到n的顺序依次将数据插入可持久化的线段树中，将会得到n+1个版本的线段树（包括初始化的版本），将其编号为0~n。

可以发现所有版本的线段树都拥有相同的结构，它们同一个位置上的结点的含义都相同。

考虑第i个版本的线段树的结点P，P中储存的值表示[1,i]这个区间中，P结点的值域中所含的元素个数；

假设我们知道了[1,R]区间中P结点的值域中所含的元素个数，也知道[1,L-1]区间中P结点的值域中所包含的元素个数，显然用第一个个数减去第二个个数，就可以得到[L,R]区间中的元素个数。

因此我们对于一个查询[L,R]，同步考虑两个根root[L-1]与root[R]，用它们同一个位置的结点的差值就表示了区间[L,R]中的元素个数，利用这个性质，从两个根节点，向左右儿子中递归的查找第K小数即可。 

对于前缀[1,i]和前缀[1,i+1]的线段树，如果b[i+1]<=mid (b[i+1]表示a[i+1]离散后的标记)
那么线段树i和线段树i+1的左边是完全相同的，根本不需要在建，只需要用指针指一下就好；
那么对于一棵新的线段树其实我们最多要建的节点数为log(n)

代码如下，参考了kuangbin的，orz bin神

/**
 * @author neko01
 */
//#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <cstring>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>
#include <cmath>
#include <set>
#include <map>
using namespace std;
typedef long long LL;
#define min3(a,b,c) min(a,min(b,c))
#define max3(a,b,c) max(a,max(b,c))
#define pb push_back
#define mp(a,b) make_pair(a,b)
#define clr(a) memset(a,0,sizeof a)
#define clr1(a) memset(a,-1,sizeof a)
#define dbg(a) printf("%d\n",a)
typedef pair<int,int> pp;
const double eps=1e-9;
const double pi=acos(-1.0);
const int N=100010;
const int M=N*30;
int a[N]; //原数组
int b[N]; //排序后数组
int T[M]; //T[i]表示a1a2,,,ai所对应的线段树
//线段树中维护某个值域中的元素个数
int lson[M],rson[M];
int c[M]; //储存的值表示[1,i]这个区间中，对应的线段树结点的值域中所含的元素个数
int n,m;  //m为离散化后的值域最大值
int tot;
void init_hash()
{
    sort(b+1,b+1+n);
    m=unique(b+1,b+1+n)-(b+1);
}
int hash(int x)
{
    return lower_bound(b+1,b+1+m,x)-b;
}
int build(int l,int r)
{
    int root=tot++;
    c[root]=0;
    if(l!=r)
    {
        int mid=(l+r)>>1;
        lson[root]=build(l,mid);
        rson[root]=build(mid+1,r);
    }
    return root;
}
int update(int root,int pos,int x)  //以值域建n个线段树
{
    int newroot=tot++,tmp=newroot;
    c[newroot]=c[root]+x;
    int l=1,r=m;
    while(l<r)
    {
        int mid=(l+r)>>1;
        if(pos<=mid)
        {
            lson[newroot]=tot++;
            rson[newroot]=rson[root]; //右儿子还是上一个线段树的
            newroot=lson[newroot];
            root=lson[root];
            r=mid;
        }
        else
        {
            rson[newroot]=tot++;;
            lson[newroot]=lson[root];       //左儿子还是上一个线段树的
            newroot=rson[newroot];
            root=rson[root];
            l=mid+1;
        }
        c[newroot]=c[root]+x;
    }
    return tmp;
}
int query(int lr,int rr,int k)
{
    int l=1,r=m;   //值域
    while(l<r)
    {
        int mid=(l+r)>>1;
        if(c[lson[lr]]-c[lson[rr]]>=k)  //表示区间[lr,rr]内值在[1,mid]的个数
        {
            r=mid;
            lr=lson[lr];
            rr=lson[rr];
        }
        else
        {
            l=mid+1;
            k-=c[lson[lr]]-c[lson[rr]];
            lr=rson[lr];
            rr=rson[rr];
        }
    }
    return l;
}
int main()
{
    int q;
    while(~scanf("%d%d",&n,&q))
    {
        tot=0;
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            b[i]=a[i];
        }
        init_hash();
        T[n+1]=build(1,m);
        for(int i=n;i>0;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",b[query(T[l],T[r+1],k)]);
        }
    }
    return 0;
}

部分参考于：http://www.cnblogs.com/zinthos/p/3899565.html