POJ2104 K-th number 函数式线段树
很久没打代码了,不知道为什么,昨天考岭南文化之前突然开始思考起这个问题来,这个问题据说有很多种方法,划分树什么的,不过对于我现在这种水平还是用熟悉的线段树做比较好。这到题今年8月份的时候曾经做过，那个时候是作为对函数式线段树的一个基础题来做的，那个时候不懂，看着别人的代码对拍然后摸索下来，所以到了昨天我就已经彻底忘了，因为代码不是自己写的。昨天想了很久，终于参透了它的精髓。
首先对于给出的a[1]~a[n]这么多个数离散化，然后建立一个线段树，线段树中的结点对应的区间[L,R]表示的是在[L,R](离散化后的值)中有多少个数。
举个例子，a={1,3,2,6,4,7} 那么假如我对这整个数组建线段树，[3,6]的sum应该为2，因为[3，6]里只有3和5在数组里。
函数式的思想是，假如我建出来从a[1]~a[i]对应的线段树T[i],那么当我要去求数组中的某一段[x,y]在[L,R]里有多少个的时候，实际上就是T[y].[L,R]的和-T[x-1].[L,R]的和，这样我们就可以知道，在数组的a[x]~a[y]里在范围在L-R中的数有多少个。这样的话我们可以二分出第kth值。
即从0~size,如果0~mid里已经有超过k个了，说明第k大在左边，否则第k大在右边，这样查找就可以了。这次我终于写出了一个自己的二分。以前二分都是lower_bound水过，如果要用到的话，我会在l+1=r的时候特判，特别猥琐，看了一篇关于二分的总结才知道，二分的写法有分左闭右闭和左开右开的，不过这些都要慢慢领悟了。
再谈谈怎么建线段树，假如我们已经建了线段树T[i],那么当我们要建线段树T[i+1]的时候，如果再建一次空间会非常大，所以要充分利用T[i]的信息，实际上建立T[i+1]的时候只比T[i]多了一个值，所以我们只需要延着路径重建这些新的结点就好，另外一边的只需要用回历史版本的就好。延着线段树往下会修改到logn个结点，所以建立T[0]时需要开4*n,再加上后来每个一个都要logn个结点，所以总的结点数是(4+logn)*n. logn=16.多，这也就是为什么我们的结点数要开到20倍，所以这种树对空间的消耗是蛮大的。
想想之前线段树都要套模板，现在可以自己敲出来，这一年里还是有进步的。我还是慢慢努力练习练习吧~
贴一记代码，1700ms，非常慢，权当学习- -0
#include<iostream>
#include<algorithm>
#include<cstring>
#include<string>
#include<cstdio>
#include<cmath>
#define maxn 100000
using namespace std;
struct Node
{
int l,r,sum;
Node *lc,*rc;
}N[20*maxn];
int top;
Node *root[100050];
int n,m;
int a[maxn+20];
int b[maxn+20];
int bsize;
Node *build(int L,int R)
{
if(L==R){
Node *ret=&N[top++];
ret->l=L;ret->r=R;ret->sum=0;
ret->lc=NULL;ret->rc=NULL;
return ret;
}
else{
Node* ret=&N[top++];
int M=(L+R)>>1;
ret->l=L;ret->r=R;
ret->lc=build(L,M);ret->rc=build(M+1,R);
ret->sum=ret->lc->sum+ret->rc->sum;
return ret;
}
}
Node *build(int L,int R,int k,Node *p) // 对key值k,和历史版本的p重建树
{
if(L==R){
Node *ret=&N[top++];
ret->l=L;ret->r=R;ret->sum=p->sum+1;
ret->lc=NULL;ret->rc=NULL;
return ret;
}
else{
int M=(L+R)>>1;
Node *ret=&N[top++];
ret->l=L;ret->r=R;
if(k<=M){
ret->lc=build(L,M,k,p->lc); // k值在原树的左边的时候要重建左子树
ret->rc=p->rc; // 右子树不变，用历史版本
ret->sum=ret->lc->sum+ret->rc->sum; // 更新和值
return ret;
}
else{
ret->rc=build(M+1,R,k,p->rc); // k值在原树的右边的时候要重建右子树
ret->lc=p->lc; // 左子树不变，用历史版本
ret->sum=ret->lc->sum+ret->rc->sum; // 更新和值
return ret;
}
}
}
int query(Node *p,int L,int R) // 对结点p的[L,R]区间求和值
{
if(p->l==L&&p->r==R){
return p->sum;
}
else{
int M=(p->l+p->r)>>1;
if(R<=M) return query(p->lc,L,R);
else if(L>M) return query(p->rc,L,R);
else return query(p->lc,L,M)+query(p->rc,M+1,R);
}
}
int search(int x,int y,int k) //找从x到y上的区间第k大
{
int l=0,r=bsize;int mid,num;
while(l<r){
mid=(l+r)>>1;
num=query(root[y],l,mid)-query(root[x-1],l,mid); // 算出<=mid的有多少个，利用区间可以减的性质
if(k<=num) r=mid;
else{
k-=num;l=mid+1;
}
}
return l;
}
int main()
{
while(cin>>n>>m)
{
for(int i=0;i<n;++i){
scanf("%d",&a[i]);
b[i]=a[i];
}
//离散化的过程
sort(b,b+n);bsize=unique(b,b+n)-b;
for(int i=0;i<n;++i){
a[i]=lower_bound(b,b+bsize,a[i])-b;
}
top=0;
root[0]=build(0,bsize);
for(int i=1;i<=n;++i){
root[i]=build(0,bsize,a[i-1],root[i-1]); // 根据a[i-1]的值，以及上一个版本的树建立新的子树
}
int li,ri,ki;
for(int i=0;i<m;++i){
scanf("%d%d%d",&li,&ri,&ki);
printf("%d\n",b[search(li,ri,ki)]);
}
}
return 0;
}