Theoretical

Computer Science
ELSEVIER Theoretical Computer Science 188 ( 1997) 22 I-230

Note
Optimal algorithms for generalized searching
in sorted matrices

Abstract

We present a set of optimal and asymptotically optimal sequential and parallel algorithms
for the problem of searching on an no x n sorted matrix in the general case when noG/T.
Our two sequential algorithms have a time complexity of O(nzlog(2nlm)) which is shown
to be optimal. Our parallel algorithm runs in O(log(logm/loglogm) log(2n!n*~)) time using
ml log(logm/log logm) processors on a COMMON CRCW PRAM, where O<: < I is a mono-
tonically decreasing function on IU, which is asymptotically work-optimal. The two sequential
algorithms differ mainly in the ways of matrix partitioning: one uses row-searching and the other
applies diagonal-searching. The parallel algorithm is based on some non-trivial matrix partition-
ing and processor allocation schemes. All the proposed algorithms can be easily generahzcd for
searching on a set of sorted matrices.

KL~~XYII&:CRCW PRAM; Matrix search problem; Optimal algorithm; Processors: Sorted matrix.
Time complexity; Work-optimal

I. Introduction

We say that a matrix is sorted if all elements in each row and column are sorted in
non-decreasing (lexicographical) order, respectively. Order statistics, especially selec-
tion, on sorted matrices has received much attention [2,7,8, 11, 12, 15, 16, 18, 191 due
to its important applications in many fields [8,9, 13, 14, 171. Closely related to selec-
tion is the problem of searching a sorted matrix for the occurrence of a given element
(key), which we call the mulr& seuvch problem. This problem arises in many

* E-mail: h.shen~cit.gu.edu.au.
This work was done while the author was visiting Department of Computer Science, Abe Akademi
University, Finland.

0304.3975/97/$17.00 @ l997-Elsevier Science B.V. All Fights reserved

PII SO304-3975(97)00027-3
222 H. Shenl Theoretical Computer Science 188 (1997) 221-230

applications such as image processing and computational biology, and hence, has at-
tracted considerable attention [ 1,3-6, 161.
It has been proven that searching on an n x n sorted matrix requires n(n) time [3].
Optimal sequential algorithms for this case exist in the literature [ 1,5]. Work-optimal
parallel algorithm for this case has been given in [16], that runs in O(log logn) time
on a COMMON CRCW PRAM. Other parallel algorithms have also been developed
for searching on sorted matrices [4] and on matrices with sorted columns [lo].
In this paper we study the problem of generalized searching in m x n sorted matrix,
where m <n. Clearly for this problem, O(n) is no more a lower bound when m = o(n),
and hence simply applying the existing n x IZ matrix searching algorithms will not be
able to reach optimum in this case. Neither can trivial generalization of the existing
results by splitting X into [n/ml m x m submatrices and searching each submatrix
individually reduce the total work to below O(n) (0( [H/mlm) = O(n)). It seems that
not much work has been reported on optimal solutions to the generalized matrix search
problem in the case m <n.
The main contributions of this paper are the following:
l We propose two optimal sequential algorithms based on row-searching and diagonal-
searching respectively, both running in O(m log(2nlm)) time. We claim the optimality
by showing that n(m log(n/m)) is a lower time bound for the matrix search problem
in the general case when m dn.
l We present an asymptotically work-optimal parallel algorithm that runs in
O(log(log m/ log log m) log(2n/m- )) time using m/ log(log m/ log log m) processors
on a COMMON CRCW PRAM, where O<z < 1 is a monotonically decreasing
function m.
We present our optimal sequential algorithms in Section 2 and asymptotically optimal
parallel algorithm in Section 3, and conclude the paper in Section 4 with some open
problems for future research.

2. Optimal sequential matrix searching

Consider the problem of searching for a given element in an m x n sorted matrix

in the general case mdn. A straightforward solution is to search m rows one by one
using binary search, which requires a total time of O(m logn) and is optimal only
when m = o(n). Another naive algorithm searches either m x m submatrices one by
one employing the known optimal n x12 matrix searching algorithms, yielding O(n) time
in total, which is optimal only when m = O(n). Neither of these are optimal globally
for the general case m <n. In this section we present two algorithms running in time
O(m log(2nlm)) for the generalized matrix search problem. Our first algorithm is based
on row-searching and has a simple structure. The second algorithm using diagonal-
searching approach is slightly more sophisticated, but saves an additive factor in time
complexity. We claim that both algorithms achieve optimality by showing the lower
bound for the problem.
 H. Shen I Theoretid Cm~putrr Science 188 i 1997) 2.?1-230 223

Throughout the paper we assume that X is an m x n sorted matrix, 4 <m <n, and
e the element to be searched for. When m < 4, simply applying the naive algorithm
searching rows one by one will reach the optimum.
The basic idea behind both our algorithms is the following: searching proceeds in
pkast~s on some submatrices with reduced sizes, where in each phase a maximal number
of elements which cannot be candidates for e are discarded.
We lay X in the Cartesian plane and let X(0,0) (the small est) be at the southwest
comer and X(m - 1, n - 1) (the largest) at the northeast comer. Our first algorithm
works by repeatedly searching for a pivot element on the middle row of X which splits
X into submatrices. The algorithm is given as the following procedure and runs by
call Search-l(e, X[(O,O),(m - I.n - I)]):

Algorithm Search-l(e, X[(l-. c), (a, c)])

{*Search for es occurrence in G x i sorted matrix X[(r.c),(r.c)].*}

0. + = y - I; /j ZZL.~ (;
if (4 < 4) v (6 < 4) then {Use binary search on rows/columns; Exit};
1. Use binary search to find a pivot element xf,, on the middle row indexed F = r-+&.,2
such that .u,y,j<e<x,,,l;
2. if (e =_Y,,) v (e =x.,+1) then {e is found; Quit};
3. if e < x,:,~,then Search-l(e, X[(F + I,c),(Y,(,)])
else if e > x~,~I then Search-l(e, X[(F+ l,c),(r,c)])
else {Search-l(e, X[(F+ I,c),(r,j)]); Search-l(e, X[(r.,j + l).(F.c)]).}
{*Search in Xv, and Xs, submatrices of reduced size.*}

The correctness of the algorithm is established by the following Lemma.

Lemma I. Duriaq e&z phase of recursion in ulolorithm Search-l ull the elements
disccrrdtd umnot he candidates ,fbr e.

Proof. The lemma results directly from a standard argument based on the following
fact:
In each phase of recursion X is divided into 4 submatrices according to the pivot
element found in Step 3: Xsw = X[(r,c).(J,j)], XNW = X[(F+ l,c),(r,j)], Xyr, =
X[(r + l,,j + l),(~,c)] and Xs, = X[(v,j + l),(F,c)]. Clearly, e @ Xsw if r > ?c,,.
and e $XNE if e < .~,~+l. 0

Now we analyze the time complexity of the algorithm. Let t(m,n) be the time
complexity for searching on X. Clearly, the algorithm decomposes t(m,n) into three
parts required for finding x,~,.,, searching on X,, and searching on X~E. So we have
the following recurrence:

t( 1,n) = O(logn), t(m, 1) = O(logm).

t(m, n) = t(m/2,j) + t(m/2, n - j) + O(log n). (1)

224 H. ShenlTheoretical Computer Science 188 (19971 221-230

It is easy to verify that t(m, n) is maximized when IXNwI = IXsEI, that is, j = n/2.
In this case X is halved in both dimensions in each phase of recursion, so at the end
there are m remaining submatrices, all with dimension 1 x n/m, to be searched. Thus,
we obtain the solution of Eq. (1) as follows and leave the detailed proof to the reader:

t(m,n) = O(2m log(2n/m) - log(n/4)) = O(m log(2n/m)). (2)

Our second algorithm splits X in each phase via searching for a pivot on the main
diagonal of the middle m x m submatrix, rather than on the middle row of X. The
main diayonal of a matrix is drawn from its southwest corner to northeast corner. The
algorithm is presented as follows:

Algorithm Search-2(e, X[(r, c), (Y, c)])

{*Search for es occurrence in G x E sorted matrix X[(r,c),(v,c)].*}

& = y - 7; ; = c - c;
if (& < 4) V (ii < 4) then {Use binary search on rows/columns; Exit};
if m > n/2 then {Search-l(e, X[(r,c),( Y,c + &)I); Search-i(e, X[(r, c + k +
l), (Y, c)]); Exit};
Split X into [G/&l submatrices of dimensions 6~ x riz from west to east, where
rii = r - Y and n= c - c;
Use binary search to find a pivot element xd,a+d on the main diagonal of the middle
submatrix (the [fi/2&] th) such that Xd,A+d 6 e G&j+ i, A+d+ I ;
Steps 2-5 are the same as Algorithm-l, with xf,j and x,j+i being replaced by
Xd,D&+d and Xd+l,A+d+l, respectively, in all their context.
{*Search in 2 submatrices of reduced size.*}

The correctness of the algorithm is implied by Lemma 1.

Similar to Search-l, with the time for searching for a pivot being replaced by
O(logm), the time complexity of the algorithm follows the following recurrence:

t(l,n)= O(logn), t(m, 1) = 0( log m), t(m,m) = m,

y +d) +t (d,? -j) +O(logm).

Clearly, t(m,n) reaches maximum when d = m/2. In this case each phase of re-
cursion halves both dimensions, so there are m submatrices of dimension 1 x n/m
remaining at the end which will be searched for e. Thus, it is easy to show that the
solution of Eq. (3) is

t(m,n) = O(m log(2n/m) + m - log(m/4)) = O(m log(2nlm)). (4)

We now show that 0(m log(n/m)) is a lower bound on the time complexity for our
search problem, and hence prove the optimality of both of the above algorithms.
 H. Shrnl Theorriicul Computer Srirnce 188 11997) 221 230 225

Any pair of elements across different X, and X, are unordered.

: : : zw
: :: : : : : :
:
: :
: :. .... .. . .. .. ...... ...._..,................_

(=21) Sorted order: small- large

Fig. I. Off-diagonal slice X, in row i for O<i<6 in a 7 x 21 sorted matrix

Lemma 2. Gicen an m x n sorted matrix X, m <n, und element e, un> nlcqorithnl

srarching,fiw the occurrence of e in X requires Q(mlog(n,Jm)) tinw in the Hw.st cusc.

Proof. Along the same line as in [3] for proving the lower bound f?(n) for seraching
in an n x n square sorted matrix, we use the following argument for our proof.
Construct off-diagonal slice X; = {X[ 2, ( m ~ i ~ l)n/m]. X[i,(m - i - I)njm +
11,. .X[i, (m - i)rz/m ~ l]} m row i of X, 0 6 i < m - 1, as depicted in Fig. 1. Clearly,
X, contains a sorted sequence of nJm elements.
We know that searching X, for e in the worst case for large rank of e requires
log I/Y,, = log(n/m) comparisons and hence, O(log(n/nz)) time for any i. Since V-r, E
X, and Vx, E X, there is no order between xi and x, for 06 i # j <m - 1 (this can be
easily seen from Fig. 1), searching for e in X0 UX, U. . UX,,_ 1 requires to search each
individual X, for e, for i = 0, 1, . . . ,m -- 1, which in the worst case takes e(m log(n,~m))
time. The lemma follows immediately from the fact that r may fall into any X, and
hence searching X contains searching U;li Xi. [3

We say that an algorithm is optimal if its time complexity matches the lower bound
for the problem. By Eqs. (2) and (4) and Lemma 2, we obtain our first theorem:

Theorem 1. Srarchiny on an m x n sorted mntris con be completed optimcrl[v it?

O(m log(2nim)) time by alqorithnzs Search-l und Search-z, \rherr m <n.

3. Asymptotically optimal parallel matrix searching

Now, we consider the generalized matrix search problem in the parallel environment.
For searching on an n x n sorted matrix X, an algorithm running in time O(log log n )
using O(n/log log n) processors on a COMMON CRCW PRAM was given in [ 161. For
226 H. Shenl Theoretical Computer Science 188 (1997) 221-230

the case, when X is of m x n dimensions, m <n, naive approaches of binary search on

Xs rows or columns immediately yield solutions with O(log n)-time O(m log n)-work
or O(logm)-time O(n logm)-work respectively. Using the algorithm in [16] may result
in a solution of O(log log m) time and O(n/log log m) processors, but its total work is
still far from the optimal bound shown in the previous section when m << n. It seems
that neither the naive approaches nor the algorithm in [ 161 can lead to work-optimal
or near-optimal solutions for the generalized matrix search problem.
Here we present a new algorithm that runs in O(log(logm/log logm)log(2n/m~))
time using m/ log(log m/log log m) processors on the COMMON CRCW model, 0 <z <
1. Our algorithm has an asymptotically optimal work when m is large enough.
The basic idea behind our algorithm is in phases to partition X into submatrices
called cells and identify those active cells possibly containing e (and discard all oth-
ers). Assume that X is divided into uv submatrices by u rows and v columns. Obvi-
ously, examining whether e occurs in X is equivalent to examining whether e exists in
each submatrix for all submatrices. A sorted matrix can be uniquely identified by its
southwest corner element x,,, and northeast corner element x,,,,,. Clearly, x,,, is the
smallest element and x,,, the largest element. We call these the two extreme elements
of the matrix. The following lemma is essential for our algorithm.

Lemma 3. IJX is divided into u x v submatrices by u equally distanced rows and

v equally distanced columns, then there are at the most u + v submatrices that may
contain e as a non-extreme element.

Proof. We use a standard approach and draw a main diagonal to connect x,in to x,,,
in each submatrix. A submatrix may contain e iff x,,, <e <xmax. Clearly all these
main diagonals lie in at most u + v diagonals of X. Since each diagonal of X is sorted
from its southwest end to the northeast end, there are at most one pair of points xi,j
and x~+I,~+~ which overlaps with the submatrixs extreme points on the diagonal such
that xi,j < e < ~i+l,j+l. Hence e may be a non-extreme element in at most u + v
submatrices.

Our algorithm works by partitioning X into rnli2 x mJ2--E cells of size m1!2 x
nmlm f2 for any small constant O< E < i, and identify all active cells (at most
m12 + m1/2-c). Repeat this partitioning process until the splitting factor on the vertical
direction (m12- ) shrinks to 1. Finally, search the sorted arrays for e in every active
cells using binary search. We present the algorithm as follows:

Algorithm CRCW-Search(e,X, m, n);

{*Search for e in m x n sorted matrix X on COMMON CRCW PRAM, m <n.*}

(1) if m <4 then find e by binary search on every row in parallel; {*Trivial case*.}
CELLS0 - {X>; mo,no - m,n; i - 0;
{*CELLS, consists of all active cells of size mi x n,, each represented by its extreme
elements, for the (i + 1)th phase of partitioning, i = 0, 1, . . ..*}
 H. Shen I Theoretical Computer Scierw 188 (1997) 22/L230 277

(2) while m2---3 1 do

2.1 i-i+l;
2.2 for every cell in CELLS,_~ do in parallel
Partition it into u, X ci == m2- x fn2- - cells of size Iy1,X n,
7-
using u, x L,processors, where 172,= m,- j/u, = m and n, =
&y;z- ,/,c:=,2-
nJ_]/li = nm
Assign one processor to each extieme element;
2.3 for every pair of extreme elements (x,,,,.~,,,) do in parallel
if (e = x,in) V (e TX,,,,) then {e is found; QUIT};
if X,in < e < I,,, then mark the corresponding cell active:
2.4 for all active cells do in parallel
CELLS, + {active cells};
(3) for every cell in CELLS, do in parallel
3.1 Allocate a set of processors to the cell;
3.2 for every processor in the cell do in parallel
3.2.1 Partition the cell into equally sized groups of rows and assign
a group to each processor;
3.2.2 Search each row within each processors group for e using binary
search:
QUIT if found.
{*Each cell in CELLS, consists of rn- sorted arrays.*}

The correctness of the algorithm is implied by the fact that only active cells may
contain e and thus all the inactive cells can be discarded in each phase of partitioning.
Now we analyze the above algorithm. Clearly, the while-loop in CRCW-Search iter-
ates lo& l/i:) times. The following lemmas are needed for our analysis:

Lemma 4. The total number of pvwessors used in Step 2 the while-loop in CRCW-
Search is bounded by 3.g()mPi., ~~herr 1 < L = 1 + rn-, <2 und 0 6 1: < I /2.

Proof. In the ith phase partitioning, since each cell in CELLS;_, is partitioned into
nz- x m2mP, new cells and among these cells there are at most m2- + m- + active
cells by Lemma 3, O<c < A, the total number of active cells in CELLS, is

lCELLS0~ = 1,

ICELLS,I = (m2- + rn*--,)ICELLS_, 1= ivrc; I~_ i > 1, (5)

where 1, = 1 + m-.
In Step 2.2 there are m2- x m2--s = m2m-P processors assigned to each cell in
CEL.LS,_l, making the total number of processors required for this step to be

(6)
228 H. Shen I Theoretical Computer Science 188 (1997) 221-230

Clearly, pi is the total number of processors required for the ith iteration of the
while-loop, since it is needed also for Step 2.3 and ICELLS,I d pi processors, by Eqs.
(5) and (6), are used in Step 2.4.
The number of processors required for Step 2 the while-loop is the maximum number
of processors required for each iteration:

p = max(pi) = ~W(l+.+, q
i (7)

Because we use a COMMON CRCW PRAM, Step 2.3 can be completed in O(1)
time. This is achieved by simply letting every processor write the result of its com-
parison to a shared variable s with initial value 1 - write 1 if = and 0 if
f, so that at the end, we know that e is found if s = 1 and not found otherwise.
All other steps inside the while-loop of Step 2 can clearly be done in 0( 1) time. So
Step 2 requires a total time of O(log(l/s)). The value of E is chosen such that the total
work of Step 2 is optimal:

lUOg(l/)m-<m/ log( l/s). (8)

It is easy to verify that the following equation is a solution of this inequality:

E = log log m/log m. (9)

By Eq. (9), Step 2 iterates i* = log(log m/log log m) times, and when it terminates,
since 2 = 1 + rn-& = 1 + l/ logm, we have the number of cells in CELLSi*

ICELLSi* 1= )L*mc:112p
= (1 + l/logm)*ml-lz*

% (1 + i*/logm)m~ogogmiogm <2m/logm, (10)

and the size mi* x Yli* of each cell in CELLSi*

mie = m2-* = mlog 1%m/logm = log m, (11)

ni* = n,i*~l,C;1,2~ = n/,1-U+lk.
~2n/ml-((*+l):-l/10gm) _- n/m--z,
(12)
where

log m
o<z=
( (log
log log m
+I
>
loglogm- 1 /logm
>
< 1.

Clearly, the value of z monotonically decreases on m.

Based on the above equations, we now claim

Lemma 5. Step 3 in CRCW-Search can be completed in time O(log(logm/log logm)

log(2n/m-)) using m~log(logm/loglogm) processors, where Odz < 1 is a mono-
tonically decreasing function on m.
 H. Shen I Theoretircrl Computer Science I88 (1997) Z-230 229

Proof. We show the processor allocation scheme for Step 3. By Eq. (10) at the most
2m/logm active cells in total exist when entering Step 3. So in Step 3.1, we can
allocate log m/(2 log(logm/ log logm)) processors to each active cell. By Eq. (11)
there are log m (sorted) rows in each cell, therefore, we shall assign a group of
2 log(logm!loglogm) rows to one processor within the cell (Step 3.2.1). Since a row
in each cell is of length 2n,/mpz by Eq. (12), binary search on it in Step 3.2.2 requires
O(log(2n/m~ )) time. Thus, the total time required for Step 3 is O(log(log m/ log log m)
log(2n!m-)). 0

Combining Steps 2 and 3, we immediately have the following theorem.

Theorem 2. Searrhing on an m x n sor-ted nzutri.u (m <n) can he completed in

O(log(log m/log log m) log(2n/m-)) time using m/ log(log ml log log tn) procrssors on
u COMMON CRCW PRAM, where 06-7 < 1 is u ntonotonidl~~ decrrusin~g firnc-
tion on m.

It is clear that our algorithm CRCW-Search is asymptotically work-optimal, as 2 - 0

when m + 30.

4. Concluding remarks

We have proposed two optimal O(mlog(2n/m))-time sequential algorithms for the

problem of searching an m x n sorted matrix for element e that is optimal in the
general case when m<n, whereas, existing algorithms may lead to solutions to this
problem which are optimal only for either m = H(n) or m = o(n). The basic idea
behind both algorithms is in phases to partition the matrix into some submatrices with
reduced sizes, discard all those that cannot contain e, and proceed by searching on
each remaining submatrix. The partitioning technique used in the first algorithm is row-
searching, and the one used in the second algorithm is diagonal-searching. We have also
presented a parallel algorithm running in O(log(log m/ log log m) log(2n,Im -)) time
using m/ log(log m/ log log m) processors on a COMMON CRCW PRAM, 0 <z < 1 is
a monotonically decreasing function on m, which is asymptotically work-optimal. The
parallel algorithm is developed by using non-trivial problem partitioning and processor
allocation schemes.
All our algorithms can be employed for searching on a set of sorted matrices
in a straightforward way by searching either on each matrix individually or on the com-
bined sorted matrix in which all given matrices are padded along the main diagonal
[16, IS].
We believe that the techniques we developed for problem partitioning and processor
allocation may be applicable for solving other relevant problems on order statistics on
partially ordered structures.
230 H. Shenl Theoretical Computer Science 188 (1997) 221-230

Below are some open problems for future research:

l Whether we can eliminate the &-factor in the time complexity of our parallel algo-
rithm and make the algorithm optimal for any m.
l Design of work-optimal parallel algorithms on CREW and EREW PRAM.

Acknowledgements

The author wishes to thank RalphhJohan Back for his support during the course
of this work while the author was visiting Abe Akademi University. Thanks also to
an anonymous referee for various constructive comments that have strengthened the
results of this paper.

[I] S. Baase, Computer Algorithms, Assison-Wesley, Reading, MA, 1988.

[2] M. Cosnard, .I. Duprat, A. Ferreira, The complexity of searching in X + Y, Theoret. Comput. Sci. 67
(1989) 115~120.
[3] M. Cosnard, J. Duprat, A. Ferreira, The complexity of searching in X + Y and other multisets, Inform.
Process. Lett. 34 (1990) 1033109.
[4] M. Cosnard, A. Ferreira, Parallel algorithms for searching in X + Y in: Proc. 1993 Intemat. Conf.
Parallel Processing vol 3: Algorithms and Applications, Pennsylvania State University Press, 1989.
[5] D. Cries, The Science of Programming, Springer, Berlin, I98 I.
[6] A.G. Ferreira, Parallel search in sorted multisets, and np-complete problems, in: R.B. Yates, U. Manber,
Computer Science, Research and Applications: Proceedings of the I I th International Conference of the
Chilean Computer Science Society Plenum Press, New York, 3833393.
[7] G.N. Frederickson, D.B. Johnson, Generalized selection and ranking: sorted matrices, SIAM J. Comput.
(1984).
[8] G.N. Frederickson, D.B. Johnson, Generalized selection and ranking: sorted matrices, SIAM J. Comput.
(1984).
[9] J.I. Hodged, E.L. Lehmann, Estimates of location based on rank test, Ann. Math. Statist. 34 (1963)
598-611.
[IO] A. Jain, Parallel search in matrices with sorted columns, in: Proc. 7th IEEE Symp. Parallel and
Distributed Processing, IEEE Computer Society Press, Silver Spring MD, 1995.
[I l] D.B. Johnson, D.S. Kashdan, Lower bounds for selection in X + Y and other multisets. J. ACM 25
(1978) 556-570.
[12] D.B. Johnson, T. Mizoguchi, Selecting the Kth element in X + Y and Xi +X2 + .,X,. SIAM J.
Comput. 7 (1978) 147-153.
[13] 0. Kariv, S.L. Hakimi, An algorithmic approach to network location problems i: The p-centers, SIAM
J. Appl. Math. 37 (1979) 539-560.
[14] N. Megiddo, A. Tamir, E. Zemel, R. Chandrasekaran, An O(n log2 n) algorithm for the kth longest path
in a tree with applications to location problems, SIAM J. Comput. 1981.
[15] A. Mirzaian, E. Arjomandi, Selection in X + Y and matrices with sorted rows and columnss. Inform.
Process. Lett. 20 (1985).
[16] R. Samath, X. He, Efficient parallel algorithms for selection and searching on sorted matrices, in: 6th
Internat. Parallel Processing Symposium. IEEE Computer Society Press, Silver Spring, MD, 1992.
[17] MI. Shames, Geometry and statistics. in: J.F. Traub (ed.), Algorithms and Complexity: New Directions
and Recent Results, Academic Press, New York, 1992, pp. 2577280.
[18] H. Shen, Generalized parallel selection in sorted matrices, in: 8th IEEE Symp. Parallel and Distributed
Processing. IEEE PRess, 1996.
[I91 H. Shen, S. Ramnath, Optimal parallel selection in sorted matrices. Inform. Process, Lett., 59 (1996)
117-122.