【Nov 1P4,快排、插排还是？】黑匣子
【题目描述】
Black Box是一种原始的数据库。它可以存储一个整数数组，还有一个特别的变量i。最开始的时候Black Box是空的，而i等于0。这个Black Box要处理一串命令。
命令只有两种：
ADD（x）：把x元素放进Black Box；
GET：i加1，然后输出Black Box中第i小的数。
记住：第i小的数，就是Black Box里的数按从小到大的顺序排序后的第i个元素。
例如：
我们来演示一下一个有11个命令的命令串。（如下图所示）
现在要求找出对于给定的命令串的最好的处理方法。ADD和GET命令分别最多有200000个。
现在用两个整数数组来表示命令串：
1 .A( 1 ),A( 2 )，…A(M)：一串将要被放进Black Box的元素。每个数都是绝对不超过2000000000的整数，M≤ 200000 。例如上面的例子就是A = （ 3 , 1 , - 4 , 2 , 8 , - 1000 , 2 ）。
2 .u( 1 ),u( 2 ),…u(N)：表示第u(j)个元素被放进了Black Box里后就出现了一个GET命令。例如上面的例子中的u = （ 1 , 2 , 2 , 6 ）。输入数据不用判错。
【输入格式】
第一行，两个整数，M，N。
第二行，M个整数，表示A( 1 ) …A(M)。
第三行，N个整数，表示u( 1 )…u(N)。
【输出格式】
输出Black Box根据命令串所得出的输出串，一个数字一行。
【输入样例】
7 4
3 1 - 4 2 8 - 1000 2
1 2 6 6
【输出样例】
3
3
1
2
【数据规模】
对于30%的数据，M≤ 10000 ；
对于50%的数据，M≤ 100000
对于100%的数据，M≤ 200000
由于要频繁取出第X小值，很容易让人想到堆这种高效的数据结构，事实证明这种想法是正确的，G3的Bensen神牛就用了一种传说中的“一个大根堆+一个小根堆”的神奇方法A掉此题。可是弱小的我在堆里徘徊了一个多小时，最后还是放弃打这条路打了快排…
首先是快排的代码。只要会编程的人都会打，模拟插入的过程一个一个的插入就可以，纯粹的NlogN～但是快排中也有技巧，有的童鞋写的快排能得50分，而我的朴素快排只有30…在这里仅供参考，不再深入探讨。
参考代码（快排,30）:
blackbox
1 program blackbox;
2 var
3 tot,p:longint;
4 m,n,i,j:longint;
5 a: array [ 1 .. 200000 ] of longint;
6 aa,u: array [ 1 .. 200000 ] of longint;
7 procedure qsort(l,r: longint);
8 var
9 i,j,x,y: longint;
10 begin
11 i: = l;
12 j: = r;
13 x: = a[(l + r) div 2 ];
14 repeat
15 while a[i] < x do
16 inc(i);
17 while x < a[j] do
18 dec(j);
19 if not (i > j) then
20 begin
21 y: = a[i];
22 a[i]: = a[j];
23 a[j]: = y;
24 inc(i);
25 j: = j - 1 ;
26 end ;
27 until i > j;
28 if l < j then
29 qsort(l,j);
30 if i < r then
31 qsort(i,r);
32 end ;
33 begin
34 readln(m,n);
35 for i: = 1 to m do
36 read(aa[i]);
37 for i: = 1 to n do
38 read(u[i]);
39 p: = 1 ;
40 tot: = 0 ;
41 j: = 0 ;
42 for i: = 1 to m do
43 begin
44 inc(tot);
45 a[tot]: = aa[i];
46 qsort( 1 ,tot);
47 while u[p] = i do
48 begin
49 inc(j);
50 writeln(a[j]);
51 inc(p);
52 end ;
53 if p > m then break;
54 end ;
55 end .
其实这个过程和插入排序很像…So我打了个插排，以为在一定情况下效率高于快排，但是还是30～
参考代码（插排，30）
blackbox
1 program blackbox;
2 var
3 tot,p:longint;
4 m,n,i,j:longint;
5 a: array [ 1 .. 200000 ] of longint;
6 aa,u: array [ 1 .. 200000 ] of longint;
7 procedure qsort(x:longint);
8 var
9 i,j:longint;
10 begin
11 i: = 1 ;
12 while (a[i] <= x) and (i <= tot - 1 ) do inc(i);
13 for j: = tot downto i + 1 do a[j]: = a[j - 1 ];
14 a[i]: = x;
15 end ;
16 begin
17 readln(m,n);
18 for i: = 1 to m do
19 read(aa[i]);
20 for i: = 1 to n do
21 read(u[i]);
22 p: = 1 ;
23 tot: = 0 ;
24 j: = 0 ;
25 for i: = 1 to m do
26 begin
27 inc(tot);
28 qsort(aa[i]);
29 while u[p] = i do
30 begin
31 inc(j);
32 writeln(a[j]);
33 inc(p);
34 end ;
35 if p > m then break;
36 end ;
37 end .
其实对付这种题还有一个利器——二叉排序树～其实建树的过程就是ADD的过程，这个谁都会，关键是找到第K小值。
我们用一个域表示当前节点的左儿子数。这样从根节点开始，如果k-1比当前节点的左儿子少，就在它的左子树中找，如果大就在右子树中找，相同就说明找到了。这样用一个递归就可以解决问题，编程复杂度很低～
参考代码（二叉排序树，100）：
1 program blackbox;
2 type l = record
3 nn:longint; // nn表示这个节点的权
4 l,r,s:longint; // l是左节点，r是右节点，s是左儿子数
5 end ;
6 var
7 t,x,y,p:longint;
8 m,n,i,j:longint;
9 a: array [ 1 .. 200000 ] of l;
10 aa,u: array [ 1 .. 200000 ] of longint;
11 procedure print(x,po:longint);
12 begin
13 if a[po].s = x then
14 begin
15 writeln(a[po].nn);
16 exit;
17 end ;
18 if a[po].s > x then print(x,a[po].l); // 递归左子树
19 if a[po].s < x then print(x - a[po].s - 1 ,a[po].r); // 右子树，要把左边的节点数减掉
20 end ;
21 begin
22 readln(n,m);
23 for i: = 1 to n do read(aa[i]);
24 for i: = 1 to m do read(u[i]);
25 p: = 1 ;
26 for i: = 1 to n do
27 begin
28 a[i].nn: = aa[i];
29 t: = 1 ;
30 while i <> 1 do // 建树
31 begin
32 if a[i].nn >= a[t].nn then
33 begin
34 if a[t].r = 0 then
35 begin
36 a[t].r: = i;
37 break;
38 end
39 else t: = a[t].r;
40
41 end ;
42 if a[i].nn < a[t].nn then
43 begin
44 if a[t].l = 0 then
45 begin
46 a[t].l: = i;
47 inc(a[t].s);
48 break;
49 end
50 else begin
51 inc(a[t].s);
52 t: = a[t].l;
53 end ;
54 end ;
55 end ;
56 while u[p] = i do // 输出
57 begin
58 print(p - 1 , 1 );
59 inc(p);
60 end ;
61 end ;
62 end .
（saltless原创，转载请注明出处）