poj 2104:K-th Number（划分树，经典题）

K-th Number

Time Limit: 20000MS		Memory Limit: 65536K
Total Submissions: 35653		Accepted: 11382
Case Time Limit: 2000MS

Description

You are working for Macrohard company in data structures department. After failing your previous task about key insertion you were asked to write a new data structure that would be able to return quickly k-th order statistics in the array segment. 
That is, given an array a[1...n] of different integer numbers, your program must answer a series of questions Q(i, j, k) in the form: "What would be the k-th number in a[i...j] segment, if this segment was sorted?" 
For example, consider the array a = (1, 5, 2, 6, 3, 7, 4). Let the question be Q(2, 5, 3). The segment a[2...5] is (5, 2, 6, 3). If we sort this segment, we get (2, 3, 5, 6), the third number is 5, and therefore the answer to the question is 5.

Input

The first line of the input file contains n --- the size of the array, and m --- the number of questions to answer (1 <= n <= 100 000, 1 <= m <= 5 000). 
The second line contains n different integer numbers not exceeding 10⁹ by their absolute values --- the array for which the answers should be given. 
The following m lines contain question descriptions, each description consists of three numbers: i, j, and k (1 <= i <= j <= n, 1 <= k <= j - i + 1) and represents the question Q(i, j, k).

Output

For each question output the answer to it --- the k-th number in sorted a[i...j] segment.

Sample Input

7 3
1 5 2 6 3 7 4
2 5 3
4 4 1
1 7 3

Sample Output

5
6
3

Hint

This problem has huge input,so please use c-style input(scanf,printf),or you may got time limit exceed.

Source

Northeastern Europe 2004, Northern Subregion

---

 

　　划分树，经典题。

　　关于划分树的解释可以参考博文：sdut 2610:Boring Counting（第四届山东省省赛原题，划分树 + 二分）。这个属于高级点的应用，至于基础的介绍，我就不多写了（懒人一个。。），可以参考这篇博客，介绍的很详细：划分树。

　　这里简单一提，划分树的主要作用是用来求“区间内第k大的元素”，这道题属于经典应用，就是赤裸裸的求一个区间内第k大的数。题目“K-th Number”已经标明了这种含义。

　　因为之前做过一道划分树的题，所以无耻的套用了上道题的代码，然后就改了改就无耻的过了。O_o，原谅我吧。

　　代码：

 #include <iostream>
 #include <stdio.h>
 #include <algorithm>
 using namespace std;
 #define MAXN 100005
 struct Divide_tree{ //划分树的结构(4个数组，2个操作)
     int arr[MAXN];  //原数组
     int sorted[MAXN];   //排序后数组
     int sum[][MAXN];  //记录第i层1~j划分到左子树的元素个数(包括j）
     int dat[][MAXN];  //记录第i层元素序列
     void build(int c,int L,int R)   //建树，主要是建立sum[][]和dat[][]数组
     {
         int mid = (L+R)>>;
         int lsame = mid-L+;    //lsame用来记录和中间值val_mid相等的，且可以分到左孩子的数的个数
                                 //简单来说就是可以放入左孩子的,与中间值val_mid相等的数的个数
         int lp=L,rp=mid+;  //当前节点的左孩子和右孩子存数的起点
         for(int i=L;i<mid;i++)  //获得一开始的lsame
             if(sorted[i]<sorted[mid])
                 lsame--;
         for(int i=L;i<=R;i++){  //从前往后遍历一遍，
                                 //确定当前节点区间内的所有元素的归属（放在左孩子或者放在右孩子）
             if(i==L) sum[c][i]=;
             else sum[c][i]=sum[c][i-];
             if(dat[c][i]<sorted[mid]){  //当前元素比中间值val_mid小，放入左孩子
                 dat[c+][lp++] = dat[c][i];
                 sum[c][i]++;
             }
             else if(dat[c][i]>sorted[mid])  //当前元素比中间值val_mid大，放入右孩子
                 dat[c+][rp++] = dat[c][i];
             else{  //当前元素值与中间值val_mid相等，根据lsame数判断放入左孩子还是右孩子
                 if(lsame){
                     lsame--;
                     sum[c][i]++;
                     dat[c+][lp++]=sorted[mid];
                 }
                 else{
                     dat[c+][rp++]=sorted[mid];
                 }
             }
         }
         if(L==R) return ;   //递归出口，遇到叶子节点
         build(c+,L,mid);   //递归进入左孩子区间
         build(c+,mid+,R); //递归进入右孩子区间
     }
     int query(int c,int L,int R,int ql,int qr,int k)
     {
         //c为树的层数，L,R为当前节点的区间范围，ql,qr为查询的区间范围，k为查询范围内第k大的数
         if(L==R)    //递归出口，返回第k大的数
             return dat[c][L];
         int s;  //记录[L,ql-1]中进入左孩子的元素的个数
         int ss; //记录[ql,qr]中进入左孩子的元素的个数
         int mid=(L+R)>>;
         if(L==ql){  //端点重合的情况，单独考虑
             s=;
             ss=sum[c][qr];
         }
         else {
             s=sum[c][ql-];
             ss=sum[c][qr]-s;
         }
         if(k<=ss)   //左孩子的元素个数大于k个，说明第k大的元素一定在左孩子区间中，到左孩子中查询
             return query(c+,L,mid,L+s,L+s+ss-,k);
         else
             return query(c+,mid+,R,mid++ql-s-L,mid++qr-s-ss-L,k-ss);
     }
 };
 Divide_tree tree;   //定义划分树
 int main()
 {
     int i,L,R,N,M,k;
     scanf("%d%d",&N,&M);
     for(i=;i<=N;i++){   //输入
         scanf("%d",&tree.arr[i]);
         tree.sorted[i]=tree.dat[][i]=tree.arr[i];
     }
     sort(tree.sorted+,tree.sorted+N+);
     tree.build(,,N);
     for(i=;i<=M;i++){  //M次询问
         scanf("%d%d%d",&L,&R,&k);
         printf("%d\n",tree.query(,,N,L,R,k));
     }

     return ;
 }

 Freecode : www.cnblogs.com/yym2013