pku2104 K-th Number

题意：给定一个序列key[1..n]和m个询问{s,t,rank}（1 <= n <= 100 000, 1 <= m <= 5 000），对于每个询问输出区间[s,t]中第rank小的值

分析：由于2761和这题差不多，且数据量是这题的10倍，所以我一开始就把2761的SBT代码交上去，结果竟然是TLE，估计是栽在了"Case Time Limit: 2000MS"上面了。最终还是用了别人的思路，由此接触到一种很巧妙的结构：归并树

归并树可以用简单的一句话概括：利用类似线段树的树型结构记录合并排序的过程。

回顾一下如何利用归并树解决这道题：

1，建立归并树后我们得到了序列key[]的非降序排列，由于此时key[]内元素的rank是非递减的，因此key[]中属于指定区间[s,t]内的元素的rank也是非递减的，所以我们可以用二分法枚举key[]中的元素并求得它在[s,t]中的rank值，直到该rank值和询问中的rank值相等；

2，那对于key[]中的某个元素val，如何求得它在指定区间[s,t]中的rank？这就要利用到刚建好的归并树：我们可以利用类似线段树的query[s,t]操作找到所有属于[s,t]的子区间，然后累加val分别在这些子区间内的rank，得到的就是val在区间[s,t]中的rank，注意到这和合并排序的合并过程一致；

3，由于属于子区间的元素的排序结果已经记录下来，所以val在子区间内的rank可以通过二分法得到。

上面三步经过了三次二分操作（query也是种二分），于是每次询问的复杂度是O(log n * log n * log n)

PS：写二分查找时要注意细节。。

/*

Problem: 2104 User: zgmf_x20a

Memory: 9708K Time: 2454MS

Language: C++ Result: Accepted

*/

#include<iostream>

#include <algorithm>

using namespace std;

#define MAXN 100000+5

#define LOGMAXN 17+5

int sortseq[LOGMAXN][MAXN],n,q,key[MAXN],s,t,rank;

struct Node{

int l,r;

}nod[3*MAXN];

void buildtree(int u,int l,int r,int deep){

int i,j,m,loop;

nod[u].l=l;

nod[u].r=r;

if(l==r){

sortseq[deep][l]=key[l];

return;

}

m=(l+r)/2;

buildtree(2*u,l,m,deep+1);

buildtree(2*u+1,m+1,r,deep+1);

i=l;j=m+1;loop=l;

while(i<=m && j<=r){

if(sortseq[deep+1][i]<sortseq[deep+1][j])

sortseq[deep][loop++]=sortseq[deep+1][i++];

else

sortseq[deep][loop++]=sortseq[deep+1][j++];

}

if(i==m+1)

while(j<=r)

sortseq[deep][loop++]=sortseq[deep+1][j++];

else

while(i<=m)

sortseq[deep][loop++]=sortseq[deep+1][i++];

}

int query(int u,int val,int deep){

if(s<=nod[u].l && nod[u].r<=t)

return lower_bound(&sortseq[deep][nod[u].l],&sortseq[deep][nod[u].r]+1,val)-&sortseq[deep][nod[u].l];//*

int res=0;

if(s<=nod[2*u].r)

res+=query(2*u,val,deep+1);

if(t>=nod[2*u+1].l)

res+=query(2*u+1,val,deep+1);

return res;

}

int main(){

int i,l,r,m,pos;

while(scanf("%d%d",&n,&q)!=EOF){

for(i=1;i<=n;i++)

scanf("%d",&key[i]);

buildtree(1,1,n,1);

while(q--){

scanf("%d%d%d",&s,&t,&rank);

rank--;//*

l=1;r=n;

while(l<r){

m=(l+r+1)/2;//*

pos=query(1,sortseq[1][m],1);

if(pos<=rank)

l=m;

else

r=m-1;

}

printf("%d\n",sortseq[1][l]);

}

}

return 0;

}

另附lower/upper_bound的用法:

lower_bound(k)	p=c.lower_bound(k)	*p>=k 且 p 最前
upper_bound(k)	p=c.upper_bound(k)	*p>k 且 p 最前