POJ 2104 K-th Number

这个题以前就做过了，用归并树+二分，2000+ms水过了。今天整理资料，zhk提到了划分树，于是去试了一下，经过几次小小的错误，最终过掉了，900+ms。时间效率很高，O(mlogn)，是区间查询第k大值的利器。

该总结的东西基本上都写在注释里面了，就不再废话了。

 

POJ 2104 K-th Number(划分树)

 1  // 从源序列开始，首先用buffer将此序列排序。
 2  // 每次划分的时候按照中点值将元素按照大小分别排在左子树和右子树，相当于一个排序的过程，用数组val记录。
 3  // 在划分的时候用数组toLeft记录每次划分时被分到左子树的元素的数目。
 4 
 5  #include  < stdio.h >
 6  #include  < string .h >
 7  #include  < algorithm >
 8 
 9  const   int  MaxN  =   100010 ;
10  int  val[ 20 ][MaxN], toLeft[ 20 ][MaxN];
11  int  srt[MaxN];
12  int  M, N;
13 
14  struct  Node {
15       int  l, r;
16  }node[MaxN << 3 ];
17 
18  inline  int  L( int  x) { return  (x << 1 ) + 1 ;}
19  inline  int  R( int  x) { return  (x << 1 ) + 2 ;}
20 
21  void  build_tree( int  s,  int  e,  int  cur_row,  int  id) {
22      node[id].l  =  s; node[id].r  =  e;
23       if (s  ==  e)
24           return ;
25       int  mid  =  (s + e) >> 1 ;
26       int  emN  =  mid  +   1   -  s;
27       for ( int  i  =  s; i  <=  e;  ++ i) {         // 记录与中位数相同的元素被分到左子树的数目。
28           if (val[cur_row][i]  <  srt[mid])     // 因为这些元素有可能被分到左子树，也有可能被分到右子树。
29              emN -- ;                         // 记录这个值便于后面的操作。
30      }
31       int  lp  =  s, rp  =  mid + 1 ;
32       for ( int  i  =  s; i  <=  e;  ++ i) {         // 计算被划分到左子树的元素个数。
33          toLeft[cur_row][i]  =  i != s ? toLeft[cur_row][i - 1 ]: 0 ;
34           if (val[cur_row][i]  <  srt[mid]) {
35              val[cur_row + 1 ][lp ++ ]  =  val[cur_row][i];
36              toLeft[cur_row][i] ++ ;
37          }
38           else   if (val[cur_row][i]  >  srt[mid])
39              val[cur_row + 1 ][rp ++ ]  =  val[cur_row][i];
40           else   if (emN) {                     // 当emN计数为0时，划分到左子树的中位数元素划分完毕。
41              val[cur_row + 1 ][lp ++ ]  =  val[cur_row][i];
42              toLeft[cur_row][i] ++ ;
43              emN -- ;
44          }
45           else
46              val[cur_row + 1 ][rp ++ ]  =  val[cur_row][i];
47      }
48      build_tree(s, mid, cur_row  +   1 , L(id));             // 递归建树。
49      build_tree(mid + 1 , e, cur_row  +   1 , R(id));
50  }
51 
52  // {[left part][query interval][right part]}        此为树的一个节点
53  // {[(LL)(RL)][(LI)(RI)][right part]}        
54  //         LL:划分到左子树的左边部分;    RL:划分到右子树的左边部分
55  //         LI:划分到左子树的中间部分;    RL:划分到右子树的中间部分
56  // 根据以上信息判断在哪个子树进行查询，并且重新计算query interval, 递归查询即可。
57 
58  int  query( int  s,  int  e,  int  k,  int  cur_row,  int  id) {
59       if (s  ==  e)                    
60           return  val[cur_row][s];
61       int  LL  =  s == node[id].l ? 0 :toLeft[cur_row][s - 1 ];     // 计算LL, LI
62       int  LI  =  toLeft[cur_row][e]  -  LL;
63       if (k  <=  LI)
64           return  query(node[id].l + LL, node[id].l + LL + LI - 1 , k, cur_row + 1 , L(id));
65       int  mid  =  (node[id].l  +  node[id].r)  >>   1 ;
66       int  RL  =  s  -  node[id].l  -  LL;                     // 计算RL, RI
67       int  RI  =  e  +   1   -  s  -  LI;
68       return  query(mid + 1 + RL, mid + 1 + RL + RI - 1 , k  -  LI, cur_row + 1 , R(id)); 
69  }
70 
71  int  main() {
72       while (scanf( " %d%d " ,  & N,  & M)  ==   2 ) {
73           for ( int  i  =   0 ; i  <  N;  ++ i) {
74              scanf( " %d " , srt + i);
75              val[ 0 ][i]  =  srt[i];
76          }
77          std::sort(srt, srt  +  N);
78          build_tree( 0 , N - 1 ,  0 ,  0 );
79           int  s, e, k;
80           for ( int  i  =   0 ; i  <  M;  ++ i) {
81              scanf( " %d%d%d " ,  & s,  & e,  & k);
82              printf( " %d\n " , query(s - 1 , e - 1 , k,  0 ,  0 ));
83          }
84      }
85       return   0 ;
86  }
87 

 

 

POJ 2104 K-th Number(归并+二分)

 1  #include  < stdio.h >
 2  #include  < string .h >
 3  #include  < algorithm >
 4 
 5  using   namespace  std;
 6 
 7  inline  int  MID( int  s,  int  e) { return  (s + e) >> 1 ;}
 8 
 9  const   int  MaxN  =   100010 ;
10  int  merge_tree[ 20 ][MaxN], n, m, dep[MaxN];
11  int  u, v, k, flag;
12 
13  void  Merge( int  begin,  int  end,  int  d) {
14       if (begin  +   1   ==  end) {
15          merge_tree[d][begin]  =  merge_tree[ 0 ][begin];
16          dep[begin]  =  d; 
17           return ;
18      }
19       int  Mid  =  MID(begin, end);
20      Merge(begin, Mid, d  +   1 );
21      Merge(Mid, end, d  +   1 );
22       int  i, j, k;
23       for (i  =  begin, j  =  Mid, k  =  begin; i  !=  Mid  &&  j  !=  end;) {
24           if (merge_tree[d + 1 ][i]  <  merge_tree[d + 1 ][j])
25              merge_tree[d][k ++ ]  =  merge_tree[d + 1 ][i ++ ];
26           else
27              merge_tree[d][k ++ ]  =  merge_tree[d + 1 ][j ++ ];
28      }
29       if (i  !=  Mid) {
30           for (; i  !=  Mid;  ++ i) merge_tree[d][k ++ ]  =  merge_tree[d + 1 ][i];
31      }
32       if (j  !=  end) {
33           for (; j  !=  end;  ++ j) merge_tree[d][k ++ ]  =  merge_tree[d + 1 ][j];
34      }
35  }
36 
37  int  search( int  begin,  int  end,  int  s,  int  e,  int  x,  int  d) {
38       int  Mid;
39       if (s  ==  begin  &&  end  ==  e) {
40           if (x  >  merge_tree[d][end - 1 ])
41               return  end  -  begin;
42           if (x  <  merge_tree[d][begin])
43               return   0 ;
44           int  u  =  begin  -   1 , v  =  end;
45           while (u + 1   <  v) {
46              Mid  =  MID(u, v);
47               if (merge_tree[d][Mid]  <=  x) {
48                   if (merge_tree[d][Mid]  ==  x)
49                      flag ++ ;
50                  u  =  Mid;
51              }
52               else
53                  v  =  Mid;
54          }
55           return  u  -  begin  +   1 ;
56      }
57      Mid  =  MID(begin, end);
58       if (s  >=  Mid)
59           return  search(Mid, end, s, e, x, d + 1 );
60       if (e  <=  Mid)
61           return  search(begin, Mid, s, e, x, d + 1 );
62       return  search(begin, Mid, s, Mid, x, d + 1 )  +  search(Mid, end, Mid, e, x, d + 1 );
63  }
64 
65  void  work() {
66       int  begin  =   - 1 , end  =  n, Mid;
67       while (begin  +   1   <  end) {
68          Mid  =  MID(begin, end);
69          flag  =   0 ;
70           int  sum  =  search( 0 , n, u, v + 1 , merge_tree[ 0 ][Mid],  0 );
71           if (flag  &&  sum  -  flag  <  k  &&  sum  >=  k) {
72              printf( " %d\n " , merge_tree[ 0 ][Mid]);
73               return ;
74          }
75           else   if (sum  <  k)
76              begin  =  Mid;
77           else
78              end  =  Mid;
79      }
80  }
81 
82  int  main() {
83       while (scanf( " %d%d " ,  & n,  & m)  !=  EOF) {
84           for ( int  i  =   0 ; i  <  n;  ++ i) scanf( " %d " , merge_tree[ 0 ]  +  i);
85          Merge( 0 , n,  0 );
86           for ( int  i  =   0 ; i  <  m;  ++ i) {
87              scanf( " %d%d%d " ,  & u,  & v,  & k);
88              u -- ; v -- ;
89              work();
90          }
91      }
92       return   0 ;
93  }
94 

 

 

转载于:https://www.cnblogs.com/destinydesigner/archive/2010/12/05/1896959.html