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 最前