HDU 2665 Kth number 主席树，函数式线段树

求区间第k大树。

通常用划分树模板就可以做了。而且空间也挺小的。

主席树也是可以的。

主席树是什么呢？看一下别人的博客

http://seter.is-programmer.com/posts/31907.html

主席树是这样的。

1. 平时在建立线段树的时候是建一棵完整的线段树。然后在这个线段树中进行操作。

2.但是在修改线段树的时候---单点修改。 可知，需要修改的结点个数是从根到叶子结点的路径上的结点个数。

   假设把需要修改的结点复制一遍，根为Root1，在操作后这些结点已经被修改，并且根是root0. 可知，从Root1进入，可以查询的信息是未修改过的信息，

  从root0进入，查询得到的是修改后的结点。如果把这些root和修改的结点都保存起来，要查看任意一次操作后的结果，都可以轻松地查询。

  主席树的优势就在这里了。 但是每次操作的空间复杂度是Log（n）的。

3.在操作中，往往是创建一个新结点，把操作的结果保存在这些新结点上。

这一题的解法是这样的：方法1：

对所有的数字进行排序，按从大到小的顺序插入线段树，线段的结点记录的是有多少个位置被加入了。所以query(u，l,r)的结果就是从根u进入，在这次操作后，l,r区间内加入的点的个数。如果查询l,r的第k大树，二分插入操作的次数，如果这次操作导致l，r区间加入的点的个数恰好为k，那说明这次加入的点所在的数字，就是该区间的第k大数

#include<cstdio>
#include<algorithm>
using namespace std;
#define maxn 2000001
int tn[maxn],tlc[maxn],trc[maxn];
int cnt ;
int newnode(){
    tn[cnt] = 0;
    tlc[cnt]= trc[cnt] = -1;
    return cnt++;
}

void add(int u,int p,int l,int r){
    if(l == r){
        tn[u] = 1;
        return ;
    }
    int mid = (l+r)/2;
    int v ;
    if(p > mid){
        v = newnode();
        if(trc[u] != -1)
        {
            int x = trc[u];
            tn[v]=tn[x],tlc[v]=tlc[x],trc[v]=trc[x];
        }
        trc[u] = v;
        add(v,p,mid+1,r);
    }
    else {
        v = newnode();
        if(tlc[u] != -1)
        {
            int x = tlc[u];
            tn[v]=tn[x],tlc[v]=tlc[x],trc[v]=trc[x];
        }
        tlc[u] = v;
        add(v,p,l,mid);
    }
    tn[u]++;
}
int query(int u,int l,int r,int L,int R){
    if(u == -1) return 0;
    if(L == l && R == r)
        return tn[u];
    int mid = (L+R)/2;
    if(mid >= r)
        return query(tlc[u],l,r,L,mid);
    else if(mid < l)
        return query(trc[u],l,r,mid+1,R);
    return query(tlc[u],l,mid,L,mid) + query(trc[u],mid+1,r,mid+1,R);
}

struct Point{
    int n,d;
};
int comp(Point a,Point b){
    return a.n < b.n;
}
Point p[100007];
int id[100007];
int main(){
    int t,n,q;
    int l,r,k,v,x;
    scanf("%d",&t);
    while(t--){
        scanf("%d%d",&n,&q);
        for(int i = 0;i < n;i++){
            scanf("%d",&p[i].n);
            p[i].d = i;
        }
        cnt = 0;
        sort(p,p+n,comp);
        id[0] = newnode();
        for(int i = 1;i <= n; i++){
            id[i] = newnode();
            x = id[i-1];
            v = id[i];
            tn[v]=tn[x],tlc[v]=tlc[x],trc[v]=trc[x];
            add(id[i],p[i-1].d,0,n-1);
        }

        for(int i = 0;i < q; i++){
            scanf("%d%d%d",&l,&r,&k);
            l--,r--;
            int low = 1,high = n;
            while(low<=high){
                int mid = (low+high)/2;
                if(query(id[mid],l,r,0,n-1) >= k)
                    high = mid-1;
                else
                    low = mid+1;
            }
            printf("%d\n",p[low-1].n);
        }
    }
    return 0;
}

第二种方法：

看起来少了一个log的复杂度，但是实际时间快了才1倍左右。

线段树的结点表示：

第i个结点表示第i大的数的个数

先对数字排序-----------离散化第几大

按从左到右的顺序，先查看该数字是第p大，那么p位置的数量+1，更新线段树。

查询l，r区间的时候，对比第l-1和r两棵线段树的区别即可知道每个区间插入的点的个数，用于求第k大

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
using namespace std;
#define maxn 2000000
int tl[maxn],tr[maxn],tn[maxn];
int cnt = 0;
//创建新结点 初始化时先newnode()一下
//0号结点便成为了一个虚拟节点，左右孩子都是自己，
int newnode(){
    tl[cnt] = tr[cnt] = tn[cnt] = 0;
    return cnt++;
}
//p是表示所有数字中第p大的数位置
//由于有虚拟节点，无论结点是否有孩子都不会有影响
int add(int v,int l,int r,int p){
    int u = newnode();
    tl[u] = tl[v], tr[u] = tr[v], tn[u] = tn[v];
    if(l == r){
        tn[u]++;
        return u;
    }
    int mid = (l+r)/2;
    if(p > mid) tr[u] = add(tr[u],mid+1,r,p);
    else tl[u] = add(tl[u],l,mid,p);
    tn[u]++;
    return u;
}
//加入第r1个数，和第r2个数所形成的线段树的跟
//用tn[r2]-tn[r1]表示加入r2-r1个数时在当前区间增加的点数
int query(int r1,int r2,int l,int r, int k){
    if(l == r) return l;
    int n = tn[tl[r2]] - tn[tl[r1]];
    if(n >= k)
        query(tl[r1],tl[r2],l,(l+r)/2,k);
    else return query(tr[r1],tr[r2],(l+r)/2+1,r,k-n);
}

int s[100007],num[100007];
int id[100007];
int main(){
    int t,n,q;
    int l,r,k,v,x;
    scanf("%d",&t);
    while(t--){
        scanf("%d%d",&n,&q);
        for(int i = 0;i < n;i++){
            scanf("%d",&num[i]);
            s[i] = num[i];
        }
        cnt = 0;
        sort(s,s+n);
        int sn = unique(s,s+n)-s;
        id[0] = newnode();
        for(int i = 0;i < n; i++){
            v = lower_bound(s,s+sn,num[i])-s;
            id[i+1] = add(id[i],0,sn-1,v);
        }
        for(int i = 0;i < q; i++){
            scanf("%d%d%d",&l,&r,&k);
            v = query(id[l-1],id[r],0,sn-1,k);
            printf("%d\n",s[v]);
        }
    }
    return 0;
}