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
#include
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
#include
#include
#include
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;
}