cis98006

Linkoping Electronic Articles in
Computer and Information Science
Vol. 3(1998): nr 06
This work has been submitted for publication elsewhere.
Copyright may then be transferred,
and the present version of the article may be superseded by a revised one.
The WWW page at the URL stated below will contain up-to-date information
about the current version and copyright status of this article. Additional
copyright information is found on the next page of this document.
Linkoping University Electronic Press
Linkoping, Sweden
http://www.ep.liu.se/ea/cis/1998/006/
Parallel Algorithms for Searching
Monotone Matrices on Coarse
Grained Multicomputers
Per-Olof Fjallstrom
Department of Computer and Information Science
Linkoping University
Linkoping, Sweden

Published on June 17, 1998 by
Linkoping University Electronic Press
581 83 Linkoping, Sweden
Linkoping Electronic Articles in
Computer and Information Science
ISSN 1401-9841
Series editor: Erik Sandewall
c 1998 Per-Olof Fjallstrom
Typeset by the author using LATEX
Formatted using etendu style
Recommended citation:
<Author>. <Title>. Linkoping Electronic Articles in
Computer and Information Science, Vol. 3(1998): nr 06.
http://www.ep.liu.se/ea/cis/1998/006/. June 17, 1998.
This URL will also contain a link to the author's home page.
The publishers will keep this article on-line on the Internet
(or its possible replacement network in the future)
for a period of 25 years from the date of publication,
barring exceptional circumstances as described separately.
The on-line availability of the article implies
a permanent permission for anyone to read the article on-line,
and to print out single copies of it for personal use.
This permission can not be revoked by subsequent
transfers of copyright. All other uses of the article,
including for making copies for classroom use,
are conditional on the consent of the copyright owner.
The publication of the article on the date stated above
included also the production of a limited number of copies
on paper, which were archived in Swedish university libraries
like all other written works published in Sweden.
The publisher has taken technical and administrative measures
to assure that the on-line version of the article will be
permanently accessible using the URL stated above,
unchanged, and permanently equal to the archived printed copies
at least until the expiration of the publication period.
For additional information about the Linkoping University
Electronic Press and its procedures for publication and for
assurance of document integrity, please refer to
its WWW home page: http://www.ep.liu.se/
or by conventional mail to the address stated above.

Abstract
We present parallel algorithms for geometric problems on coarse grained
multicomputers. More speci cally, for a square mesh-connected p-processor
computer, we show that:
1. The implicitrow maximaproblem on a totallymonotone n n matrix
can be solved in O((n=p)logp) time, if n p2
.
2. The all-farthest-neighbors problem for a convex n-gon can be solved
in O(n=pp) time, if n p2
=4.
3. The maximum-perimeter triangle inscribed in a convex n-gon can
be found in O(nlogn=pp) time, if n p2
.
The solutions to the two latter problems are based on the reduction of
these problems to searching problems in totally monotone matrices.
Keywords: Computational geometry, parallel algorithms, coarse grained
multicomputers, totally monotone matrices
The work presented here is funded by CENIIT (the Center for Industrial
Information Technology) at Linkoping University.

1
1 Introduction
Given a two-dimensional matrix A, the row maxima problem is to decide for
each row, the index of the leftmost column containing the maximum value
in the row. Let ^c(r) denote the index of the leftmost column containing the
maximum value in the r-th row. The matrix A is monotone if r1 < r2 implies
that ^c(r1) ^c(r2), and A is totally monotone if every 2 2 submatrix is
monotone.
Totally monotone matrices were introduced by Aggarwal et al. 1], who
presented e cient sequential algorithms for solvingthe row maxima problem in
monotone matrices. For example, they showed that given a totally monotone
n m matrix with n m, this problem can be solved in O(m) time. They also
showed that several geometric problems can be reduced to the row maxima
problem in totally monotone matrices. An example of such a problem is to
nd a farthest neighbor of each vertex in a given convex n-gon. This problem
can be solved in O(n) time by nding row maxima in a totally monotone
n (2n 1) matrix.
Aggarwal and Park 2] generalized the notion of totally monotone matrices
to multidimensional matrices, and exhibited several geometric problems that
can be solved by nding maxima in such matrices. For example, they showed
that the problem of nding a maximum-perimeter d-gon inscribed in a given
n-gon can be solved by nding a largest entry in a d-dimensional matrix.
They solve this problem sequentially in O(n(d + logn)) time, and in time
O((d+logn)logn loglogn) using n=loglogn processors on a CREW PRAM.
Several PRAM algorithms for nding row maxima in totally monotone
n m matrices have been proposed 2, 3, 4, 5]. In the following, we restrict
our attention to deterministic algorithms for the case n = m. Aggarwal and
Park 2] give an (logn loglogn) time and O(nlogn) work CREW algorithm.
Atallah and Kosaraju 3] give an O(logn) time and O(nlogn) work EREW
algorithm. Bradford et al. 5] give an EREW algorithm that runs in time
O(logn
plogn loglogn) and does O(n
plogn loglogn) work. Bradford et al.
also give work e cient CREW and CRCW algorithms.
Most of the research on parallel algorithms for geometric problems has fo-
cused on ne-grain parallel models of computation 6, 7, 8]. It is only during
the last couple of years that researchers have designed parallel geometric al-
gorithms for coarse grained multicomputers 9, 10, 11, 12, 13, 14, 15, 16, 17].
A coarse grained multicomputer consists of several powerful processors con-
nected by an interconnection network. For this model of computation it is
reasonable to assume that the size of each local memory is larger than the
number of processors. Many commercially available parallel computers are of
this kind.
The main results of this paper are as follows. (The time complexities refer
to a square mesh-connected p-processor multicomputer.)
1. The implicit row maxima problem on a totally monotone n n matrix
can be solved in O((n=p)logp) time, if n p2
. (For each column c, we
nd all rows r such that ^c(r) = c.)

2
2. The all-farthest-neighbors problem for a convex n-gon can be solved in
O(n=pp) time, if n p2
=4.
3. The maximum-perimeter triangle inscribed in a convex n-gon can be
found in O(nlogn=pp) time, if n p2
.
According to Brent's theorem 18], a PRAM algorithm that runs in time
t and does work w can be simulated on a p-processor PRAM to run in time
O(w=p + t). We know also that a PRAM algorithm that runs in time t and
uses pprocessors isdeterministicallysimulated intime (tpp) on a p-processor
mesh-connected computer 19].
From this follows that our algorithms are faster than the algorithms that
would be obtained by simulations of the above PRAM algorithms. For exam-
ple, by simulating the EREW algorithm of Bradford et al. on a p-processor
mesh-connected multicomputer, the all-farthest-neighborsproblemcan be solved
in O((n=p + logn)
plogn loglognpp) time. Similarly, by simulating the al-
gorithm of Agarwal and Park, the maximum-perimeter triangle inscribed in a
convex n-gon can be found in O((n=p+ loglogn)log2
npp) time.
We organize this paper as follows. In Section 2, we describe the basic op-
erations used by our algorithms. In Sections 3 and 4, we introduce the row
maxima and plane maxima problems for totally monotone matrices, describe
how these problems are related to the geometric problems we consider, and
present parallel algorithms for these problems. Section 5 o ers some conclud-
ing remarks.
2 Basic Operations
Our algorithms use a few basic operations; in the following we describe these
operations, and give their time complexities for a square mesh-connected mul-
ticomputer with p processors. The operations are assumed to use cut-through
routing. The parameters ts, th and tw denote the start-up time, per-hop time,
and per-word transfer time, respectively. For a detailed description and anal-
ysis of the operations, see Kumar et al. 20].
1. Monotone routing: Each processor P(i) sends at most one m-word mes-
sage. The destination address, d(i), of the message is such that if both
P(i) and P(i0), i < i0, send messages, then d(i) < d(i0). Monotone
routing takes O((ts + twm)pp) time.
2. Segmented broadcast: Processors with indexes i1 < i2 ::: < iq, are se-
lected; each processor P(ij) sends the same m-word message to pro-
cessors P(ij + 1) through P(ij+1) (but di erent processors may send
di erent messages). The time complexity is O((ts +twm)logp+th
pp).
3. Multinode broadcast: Every processor sends the same m-word message
to every other processor (but di erent processors may send di erent
messages). Multinode broadcasting requires O(twmp+ ts
pp) time.
4. Reduction: Given a sequence a1;a2;:::;ap of size m vectors with vector
ai stored in processor P(i), and an associative operator , the reduction

3
operation computes s j] = a1 j] ap j], j = 1;2;:::;m, with s j]
stored in each processor. The time complexity is O((ts + twm)logp +
th
pp). In segmented reduction, we apply the reduction operation to
disjoint subsequences of consecutive vectors.
3 Two-Dimensional Matrices
In this section we give parallel algorithms for nding row maxima in two-
dimensional totally monotone matrices. More speci cally, in Section 3.1 we
give an algorithm for solving the so-called implicit row maxima problem for
an explicitly given matrix. In Section 3.2, we describe an algorithm for the
all-farthest-neighbors problem for a convex polygon.
As mentioned in Section 1, Aggarwal et al. 1] showed that the row maxima
problem for a totally monotone n m matrix can be solved sequentially in
time O(m) if n m. For monotone matrices, we can also de ne the implicit
row maxima problem: for each column c, determine the pair (l(c);u(c)) such
that for every row r, if ^c(r) = c then l(c) r u(c).
For arbitrary monotone matrices, the implicit row maxima problem can be
solved in O(mlogn) time by a straightforward divide-and-conquer algorithm.
For totally monotone matrices we can do better. If n m, we can easily solve
the problem in O(m) time by rst solving the row maxima problem. For the
case n > m, Aggarwal et al. give an algorithm that runs in time O(m(1 +
log(n=m))). This implies that for arbitrary totally monotone matrices, the
row maxima problem can always be solved in O(n+ m) time.
3.1 Implicit Row Maxima of an n n Matrix
In this section we consider the implicit row maxima problem for a totally
monotone n n matrix A given explicitly. More speci cally, each processor
P(k) contains Ak, the submatrix of A consisting of columns indexed from (k
1)n=p+1 through kn=p. (For simplicity, we assume that nis an integer multiple
of p.) At the end of execution, the solution for column c, i.e., (l(c);u(c)), is
stored in the processor that contains column c. (If no row maxima are found
in column c, we set l(c) > u(c).)
Algorithm: 3.1
1. For 0 i n=p, let ri = ip. Compute ^c(ri), 1 i n=p. Let ^c(r0) = 1.
2. Let ^ci denote ^c(ri), and let Ai, 1 i n=p, be the submatrix of A
consisting of rows ri 1 + 1 through ri 1 and columns ^ci 1 through ^ci.
For each submatrix Ai, let ki 1 and ki be the indices such that ^ci 1 and
^ci are columns in Aki 1 and Aki, respectively. See Figure 1.
For each Ai such that ki 1 = ki, locally solve the implicit row maxima
problem. This solves the implicit row maxima problem for each column
c such that ^ci 1 < c < ^ci and ki 1 = ki.
3. For each Ai such that ki 1 < ki, do as follows.

4
A A A A1 2 3 4
r
r
r
r
r
r
1
2
3
4
5
6
2
3
5
6
1 2 3
43
11 1
4 4
A A A
A
A
A A
A
A
Figure 1: Example with p = 4 and n = 24. For columns in matrices A2,
A3, A5, and A6, the implicit row maxima problem is solved in Step 2. For
remaining columns, the problem is solved in Steps 3 or 4.
(a) Let Ak
i be the submatrix of Ai with its columns in Ak, ki 1 k
ki. Locally solve the implicit row maxima problem for Ak
i . Let
(lk
i (c);uk
i (c)) denote the solution for column c in Ak
i .
(b) Locally solve the row maxima problem for Ak
i . Let ^ck
i (r) denote the
solution for row r.
(c) Solve the row maxima problem for Ai. Let ^c(r) denote the solution
for row r.
(d) For r = ri 1 + 1;:::;ri 1 and ki 1 k ki, do as follows. If
r > uk
i (^ck
i (r)) then do nothing. If ^ck
i (r) < ^c(r), set uk
i (^ck
i (r)) = r 1;
otherwise, if ^ck
i (r) > ^c(r), set lk
i (^ck
i (r)) = r + 1.
4. It remains to solve the implicit row maxima problem for each column ^ci.
To do this it is su cient to combine the solutions for column ^ci in the
matrices Ai and Ai+1.
Theorem 1 The implicit row maxima problem on a totally monotone n n
matrix can be solved in O((n=p)logp) time on a square mesh-connected p-
processor multicomputer, if n p2
.
Proof. In Step 1, we rst locally solve the row maxima problem for the
submatrix of Ak consisting of rows r1;r2;:::;rn=p. This takes O(n=p) time.
Let ^ck(i), 1 i n=p, denote the solution. That is, ^ck(i) is the column in A
where the maximum value in row ri in Ak is found. Next, in each processor
P(k) create the records (A(ri;^ck(i));^ck(i)). Then, for each value of i, nd
the record with the largest rst component. (If more than one record has the
largest rst component, the one with smallest second component is selected.)
This is achieved by the reduction operation in O((ts + twn=p)logp + th
pp)
time. Finally, set ^c(ri) equal to the second component of the selected record.

5
In Step 2, the implicit row maxima problem for Ai is solved in O((^ci
^ci 1 +1)logp)) time by divide-and-conquer. In the worst case (all Ai are part
of the same Ak), Step 2 takes time O((n=p)logp).
The time complexity for Step 3(a) is the same as for Step 2. Steps 3(b)
and 3(d) take O(p + n=p) time. The computations in Step 3(c) are done by
segmented reduction operations in time O((ts + twp)logp + th
pp). The last
step takes time O(n=p). 2
3.2 All-farthest-neighbors in a convex polygon
Given a convex polygon with vertices p1;p2;:::;pn (in clockwise order), the
all-farthest-neighbors problem is to nd a farthest neighbor of each vertex.
Aggarwal et al. 1] show how to reformulate this problem as a row maxima
problem on a totally monotone matrix. More speci cally, we can solve the
problem by solving the row maxima problem for an n (2n 1) matrix A
de ned as follows:
ai;j =
8
><
>:
j i if j i
d(pi;p j) if i < j < i + n
1 otherwise,
where d(pi;pj) denotes the Euclidean distance between pi and pj, and j
denotes ((j 1) mod n)+1. To rst explicitly construct A and then solve the
row maxima problem would obviously take (n2
) time. Instead, every time a
particular entry is needed, we compute it in constant time, and the problem
can be solved in O(n) time. In this section, we show how the all-farthest-
neighbors problem can be solved on a multicomputer.
To simplify the exposition, we assume that 2n is an integer multiple of
p, and that p is even. Initially, the vertices are distributed as follows over
the processors: processors P(k) and P(k + p=2), k = 1;2;:::;p=2, contain
vertices pj, (k 1)2n=p < j k2n=p. With processor P(k), 1 k p, is
(implicitly) associated the submatrix Ak of A consisting of columns indexed
from (k 1)2n=p+1 through k2n=p. At the end of computation the index of
a farthest neighbor of each vertex pj, (k 1)2n=p < j k2n=p, is stored in
processor P(k). For an example, see Figure 2.
Algorithm 3.2:
1. For 0 i p=2, let ri = i2n=p. Compute ^c(ri), 1 i p=2. Let
^c(r0) = 1.
2. For 1 i p=2, let Ai, ki 1 and ki be de ned as in Step 2 of Algorithm
3.1. To solve the row maxima problem for Ai such that ki 1 = ki, do as
follows.
(a) For k = 1;2;:::;p, determine the integers (if they exist) f(k) =
minfi : ki 1 = kg and l(k) = maxfi : ki = kg. That is, if f(k)
i l(k) then Ai lies completely within Ak.
(b) For k = 1;2;:::;p such that f(k) l(k), copy the vertices in
P(k) to processors P(f(k)) through P(l(k)). Locally solve the row
maxima problem for Ai, l(k) i f(k), in the processor P(i).

6
A
r
4
3
2
1
A
r
r
A
A
A
4
A A A A A1
A A4 6
r
3 5 72 8
1
2
3
Figure 2: Example with p = 8. In Step 2, the processor P(4) sends its vertices
to processors P(2) and P(3), which then solve the row maxima problem for A2
and A3, respectively. In Step 3, processors P(1) and P(4) send their vertices
to processors P(2) through P(4) and P(4) through P(7), respectively. Then,
processors P(2) through P(4) and P(4) through P(7), collectively solve the
row maxima problem for A1 and A4, respectively.
3. For each Ai such that ki 1 < ki, do as follows.
(a) Copy the vertices in P(i) to processors P(ki 1) through P(ki). Let
Ak
i be the submatrix of Ai with its columns in Ak, ki 1 k ki.
Locally solve the row maxima problem for Ak
i .
(b) Solve the row maxima problem for Ai. Copy the solution to the
processor P(i).
Theorem 2 The all-farthest-neighbors problem for a convex n-gon can be
solved in O(n=pp) time on a square mesh-connected p-processor multicom-
puter, if n p2
=4.
Proof. In Step 1, we rst broadcast each vertex pri to every processor.
Each processor P(k) has now su cient information to compute entries in row
ri in submatrix Ak. Next, we determine ^c(ri) using the same techniques as
in Step 1 of Algorithm 3.1. That is, with p=2 2n=p, Step 1 can be done in
O(n=p+ (ts + twp)logp+ th
pp) time.
Step 2(a) takes O(p) time, and the copying in Step 2(b) can be done by
monotone routing followed by segmented broadcasting. This takes O((ts +
twn=p + th)pp) time. Since each Ai is a totally monotone (2n=p 1) m0,
1 m0 2n=p, matrix, we can solve the row maxima problem in O(n=p) time.
(Note that we do not explicitly compute all of the entries in any submatrix).
In Step 3(a), it takes O((ts+twn=p+th)pp) time to copy the vertices, and
then O(n=p) time to solve the row maxima problems. In Step 3(b), the row
maxima are computed in time O((ts + twn=p)logp + th
pp) using segmented
reduction. Finally, the results are copied in O((ts + twn=p)pp) time using
monotone routing. 2

7
4 Multidimensional Matrices
Aggarwal and Park 2] generalize the row maxima problem to multidimensional
matrices. More speci cally, for d 3 let A = fai1;i2;:::;idg be an n1 n2 nd
matrix. The plane maxima problem is to determine, for i1 = 1;2;:::;n1, the
(d 1)-tuple (i2(i1);i3(i1);:::;id(i1)) such that
ai1;i2(i1);:::;id(i1) = maxi2;:::;id
ai1;i2;:::;id:
(If a plane contains several maxima, the rst in lexicographic order by second
through d-th indices is chosen.) Besides the plane maxima problem, Aggar-
wal and Park consider the tube maxima problem, in which the location of a
maximum entry is to be determined for every pair (i1;i2) of rst and second
indices.
In analogy to the two-dimensional case, A is monotone if i1 > i0
1 implies
that ik(i1) ik(i0
1) for k = 2;3;:::;d. Moreover, A is totally monotone if
every 2 2 2 d-dimensional submatrix is monotone, and every plane
(the (d 1)-dimensional submatrix corresponding to a xed value of the rst
index) is totally monotone.
Aggarwal and Park give e cient sequential and parallel algorithms for
the plane and tube maxima problems on totally monotone matrices. More
speci cally, the plane maxima of an n1 n2 nd d-dimensional totally
monotone matrix can be computed sequentially in O((nd 1 + nd) d 2
k=1
lognk)
time. Moreover, the plane maxima problem on a totally monotone n n n
matrix can be solved in time O(log2
n loglogn) using n=loglogn processors
on a CREW PRAM. Aggarwal and Park show also that several geometric and
other kinds of problems can be reduced to the plane or tube maxima problem
on totally monotone matrices. In the next section, we present one of these
problems, and give a parallel algorithm for it.
4.1 Maximum-Perimeter Inscribed Triangles
Given a convex polygon P with vertices p1;p2;:::;pn (in clockwise order), the
maximum-perimeter inscribed triangle problem is to nd a triangle T contained
in P with a maximum perimeter. Since the vertices of T must be vertices of
P, it su ces to determine the triple (i1;i2;i3), 1 i1 < i2 < i3 n, such
that per(i1;i2;i3), the perimeter of the triangle with vertices pi1 , pi2 and pi3,
is maximum. Consider the (n 2) (n 1) n matrix A where
ai1;i2;i3 =
8
><
>:
1 if i2 i1
per(i1;i2;i3) if i1 < i2 < i3
i3 i2 otherwise.
By using the quadrangle inequality (i.e., for any convex quadrangle, the sum
of the diagonals is greater than the sum of opposite sides), one can show that
every plane of A is totally monotone, and that A is monotone. This implies
that a maximum entry in A can be found sequentially in O(nlogn) time by
divide-and-conquer. In the following, we show how this problem can be solved
on a multicomputer.

8
Our algorithm is essentially a parallelization of the corresponding sequen-
tial divide-and-conquer algorithm. The main challenge is to ensure that a
processor has local access to the appropriate vertices while avoiding that it
receives too many vertices. To simplify the exposition, we assume that both
n and p are integer powers of two. In our description of the algorithm we
refer to various submatrices of matrix A. However, as in Algorithm 3.2, when-
ever a particular matrix entry is needed it is computed in constant time. Let
I(k) = fi : (k 1)n=p < i kn=pg. We de ne the k-th block of planes as
the submatrix of A consisting of all entries with index i1 2 I(k). Similarly,
the k-th block of rows (columns) consists of all entries with index i2 2 I(k)
(i3 2 I(k)). Initially, each processor P(k) contains vertices pi, i 2 I(k).
We divide the computations into two parts. Let i1(i) = ip. In Part I, we
decide the maxima for planes i1(i), i = 1;2;:::;n=p 1. That is, for each
value of i we compute (i2(i1(i));i3(i1(i))) and the value of the corresponding
entry. The rst step of Part I is that each processor P(k) broadcasts vertex
pkn=p to all processors. The rest of Part I is divided into log(n=p) phases. In
the s-th phase, s = 1;2;:::;log(n=p), we determine the maxima for planes
i1(i) = ip, where i = (2l 1)(n=p)=2s and l = 1;2;:::;2s 1
.
Let A(i), i = 1;2;:::;n=p, be the submatrices of A such that A(i) =
fai1;i2;i3g, where i1(i 1) < i1 < i1(i), and ij(i1(i 1)) ij ij(i1(i))
for j = 2;3. (We de ne i2(i1(0)) = 1, i3(i1(0)) = 2, i2(i1(n=p)) = n 1 and
i3(i1(n=p)) = n.) In Part II, we nd maximum entries in these matrices. More
speci cally, Part II consists of logp phases, and in the rst phase we compute
maximum entries in the matrices that are completely contained in a block of
rows or a block of columns. Each of the remaining matrices is decomposed
into two submatrices, which then are processed in the next phase.
We continue by describing how the s-th phase of Part I is done. At the
beginning of the s-th phase each processor has the results from previous phases
in its local memory. By the properties of A, we know that the maximum for
plane i1(i) = ip, where i = (2l 1)(n=p)=2s and l = 1;2;:::;2s 1
, lies within
the submatrix B(i) = fai1(i);i2;i3 g, where il
j(i) ij iu
j (i) for j = 2;3, and
il
j(i) and iu
j (i) are locations of plane maxima computed in previous phases.
More speci cally, il
j(i) = ij(i1(i (n=p)=2s)) and iu
j (i) = ij(i1(i + (n=p)=2s)).
In the s-th phase, we rst solve the row maxima problem for each submatrix
B(i), and then decide, for each submatrix, which of its row maxima is the
largest.
Algorithm 4.1: (s-th phase of Part I)
1. Broadcast vertices pi1(i), where i = (2l 1)(n=p)=2s and l = 1;2;:::;2s 1
,
to all processors.
2. For each matrix B(i), i = (2l 1)(n=p)=2s and l = 1;2;:::;2s 1
, and
each integer k such that il
2(i) kn=p < iu
2 (i), nd the largest entry in
row kn=p. That is, determine i3(i;k) such that
ai1(i);kn=p;i3(i;k) = max
il
3(i) i3 iu
3 (i)
ai1(i);kn=p;i3:

9
n/p 53 7n/pn/p
6
2n/p
4n/p
n/p
n/p
Figure 3: Example with p = 8 and n 64. The maxima for planes
i1(i) = n=4;n=2;3n=4, are shown by large bullets. Larger shaded regions
correspond to the matrices B(i), i = n=64;3n=64;5n=64;7n=64. Smaller bul-
lets correspond to the row maxima computed in Step 2. The darker shaded
regions represent matrices replacing matrices B(i).
3. Using the row maxima computed in the previous step, replace matrix
B(i) by submatrices. More speci cally, if il
2(i) kn=p < iu
2 (i) for k =
l(i);l(i)+1;:::;u(i), replace B(i) by submatrices B(i;j), j = l(i);l(i)+
1;:::;u(i) +1, such that B(i;j) = fai1(i);i2;i3g, where
max(il
2(i);(j 1)n=p + 1) i2 min(iu
2 (i);jn=p 1);
max(il
3(i);i3(i;j 1)) i3 min(iu
3 (i);i3(i;j)):
See Figure 3.
4. For i = 1;2;:::, let Ci = fai01(i);i2;i3 g, where il
j(i) ij iu
j (i) for j = 2;3,
be the ordered collection of matrices remaining after the previous step.
That is, i < i0 implies that iu
j (i) il
j(i0) for j = 2;3. (We de ne
i0
1(i) = i1(j) if Ci has replaced (or is identical to) B(j).)
For each matrix Ci let kl
j(i) and ku
j (i) be integers such that il
j(i) 2
I(kl
j(i)) and iu
j (i) 2 I(ku
j (i)). To solve the row maxima problem for each
matrix Ci, continue as follows.
(a) For k = 1;2;:::;p, and j = 2;3, determine the integers
fj(k) = minfi : kl
j(i) = kg, lj(k) = maxfi : ku
j (i) = kg,
f0
j(k) = maxfi : ku
j (i) < kg and l0
j(k) = minfi : kl
j(i) > kg.

10
That is, if f2(k) i l2(k), then Ci is completely contained in
the k-th block of rows. Moreover, f0
2(k) is the index of the highest-
indexed matrix that lies completely above of the k-th block of rows.
(b) For k = 1;2;:::;p such that f3(k) l3(k), unless ku
2 (f0
3(k)) =
kl
2(l0
3(k)), do:
i. Copy vertices pj, j 2 I(k), to processors P(kl
2(f3(k))) through
P(kl
2(l3(k))).
ii. Locally solve the row maxima problemfor Ci, f3(k) i l3(k),
in the processor P(kl
2(i)).
(c) For k = 1;2;:::;p such that f2(k) l2(k), unless ku
3 (f0
2(k)) =
kl
3(l0
2(k)), do:
i. Copy vertices pj, j 2 I(k), to processors P(kl
3(f2(k))) through
P(ku
3 (l2(k))).
ii. Locally solve the row maxima for Ci, f2(k) i l2(k) and
kl
3(i) = ku
3 (i), in the processor P(kl
3(i)).
iii. Solve the row maxima problem for Ci, f2(k) i l2(k) and
kl
3(i) < ku
3 (i), as in Step 3 of Algorithm 3.2.
5. Find the maximum entry in each submatrix B(i).
Lemma 1 The s-th phase of Part I takes O(n=pp) time on a square mesh-
connected p-processor multicomputer, if n=p p.
Proof. In Step 1, no processor broadcasts more than O(2s 1
=p) vertices;
this takes O(2s 1
) time. In Step 2, we solve the row maxima problem for
a totally monotone matrix B de ned as follows. Let t = (k1;k2;:::) be the
increasing sequence of integers such that k 2 t if and only if il
2(i) kn=p <
iu
2 (i) for some matrix B(i). Matrix B has n columns and one row for each
element in t. More speci cally, the entries of B are as follows:
bi2;i3 =
8
><
>:
i3 max(il
3(i);ki2 n=p) if i3 < max(il
3(i);ki2 n=p)
ai1(i);ki2n=p;i3 if max(il
3(i);ki2 n=p) i3 iu
3 (i)
1 otherwise,
where i is such that il
2(i) ki2 n=p < iu
2 (i). The row maxima problem for
B can be solved using the same techniques (and within the same amount of
time) as in Step 1 of Algorithm 3.2.
Steps 3 and 4(a) take O(n=p) time. Observe that in Steps 4(b)-(c), a single
processor may have to solve the row maxima problem for several matrices.
However, since the total number of rows and columns of these matrices is
O(n=p), these row maxima problems can be solved in O(n=p) time. The
requirement in Step 4(b) that we must not have ku
3 (f0
2(k)) = kl
3(l0
2(k)) (and
the similar requirement in Step 4(c)), guarantees that no processor receives
vertices from more than one processor. Therefore, by using monotone routing
followed by segmented broadcasting, we can copy the vertices in O(n=pp)
time.
It is easy to see that the row maxima problem for a matrix Ci remains
unsolved after Step 4(b) only if (1) kl
3(i) < ku
3 (i), or (2) kl
3(i) = ku
3 (i) = k0

11
and ku
2 (f0
3(k0)) = kl
2(l0
3(k0)). Case (1) is taken care of in Step 4(c)(iii). In case
(2) we cannot have ku
3 (f0
2(k)) = kl
3(l0
2(k)), where k = kl
2(i). Therefore, the row
maxima of a matrix Ci are determined either in Step 4(b) or in Step 4(c).
Steps 2 and 4 together compute the row maxima of each matrix B(i). The
total number of row maxima is O(n) and each processor computes O(n=p)
row maxima. In Step 5 each processor rst inspects its row maxima, and nds
a (locally) largest row maxima for each B(i). Then, by using the reduction
operation a maximum entry in each B(i) is found. Thus, Step 5 takes O(n=p+
(ts + tw2s 1
)logp+ th
pp) time. 2
As already mentioned, Part II consists of logp phases. The input to each
phase consists of an ordered set of matrices A(1);A(2);:::, each of which is
a submatrix of A. That is, A(i) = fai1;i2;i3g, where il
j(i) ij iu
j (i) for
j = 1;2;3, and iu
j (i) il
j(i0) if i < i0. Moreover, each processor has il
j(i) and
iu
j (i) in its local memory. The number of matrices is n=p in the rst phase and
O(p) in the remaining phases. For matrix A(i) and j = 1;2;3, let kl
j(i) and
ku
j (i) be the integers such that il
j(i) 2 I(kl
j(i)) and iu
j (i) 2 I(ku
j (i)). Observe
that kl
1(i) = ku
1 (i) for each A(i).
We divide the input to each phase into two subsets, M1 and M2, where M1
consists of matrices A(i) such that kl
2(i) = ku
2 (i) or kl
3(i) = ku
3 (i). For each
member of M1, we determine its maximum entry during the phase. For each
matrix of M2, we select its middle plane, determine the maximum entry for
this plane, and use this entry to replace the matrix by two new submatrices.
The set of new submatrices is the input to the next phase.
Algorithm 4.2: (s-th phase of Part II)
1. For k = 1;2;:::;p, and j = 1;2;3, determine the integers
fj(k) = minfi : kl
j(i) = kg, lj(k) = maxfi : ku
j (i) = kg,
f0
j(k) = maxfi : ku
j (i) < kg and l0
j(k) = minfi : kl
j(i) > kg.
2. For k = 1;2;:::;p such that f1(k) l1(k), unless ku
3 (f0
1(k)) = kl
3(l0
1(k)),
copy vertices pj, j 2 I(k), to processors P(kl
3(f1(k))) through P(ku
3 (l1(k))).
3 (f0
2(k)) = kl
3(l0
2(k)),
do:
(a) Copy vertices pj, j 2 I(k), to processors P(kl
3(f2(k))) through
P(ku
3 (l2(k))).
(b) For each i = f2(k);:::;l2(k), unless ku
3 (f0
1(^k)) = kl
3(l0
1(^k)), where
^k = kl
1(i), nd a maximum element in A(i).
More speci cally, for A(i) such that kl
3(i) = ku
3 (i), solve the prob-
lem locally in processor P(kl
3(i)). Otherwise, divide A(i) into sub-
matrices Al(i), kl
3(i) l ku
3 (i), such that Al(i) = fai1;i2;i3 g,
il
j(i) ij iu
j (i) for j = 1;2, and
max(il
3(i);(l 1)n=p + 1) i3 min(iu
3 (i);ln=p):
Compute a maximum element of Al(i) in processor P(l). Finally,
nd a maximum element of A(i).

12
2 (f0
1(k)) = kl
2(l0
1(k)),
copy vertices pj, j 2 I(k), to processors P(kl
2(f1(k))) through P(ku
2 (l1(k))).
2 (f0
3(k)) = kl
2(l0
3(k)),
do:
(a) Copy vertices pj, j 2 I(k), to processors P(kl
2(f3(k))) through
P(ku
2 (l3(k))).
(b) For each i = f3(k);:::;l3(k), unless ku
2 (f0
1(^k)) = kl
2(l0
1(^k)), where
^k = kl
1(i), nd a maximum element in A(i). This can be done
similarly to Step 3(b).
6. For k = 1;2;:::;p, determine the integers
f00
3 (k) = minf^k : ku
3 (f0
1(^k)) = kl
3(l0
1(^k)) = k and ku
2 (f0
1(^k)) = kl
2(l0
1(^k))g,
l00
3 (k) = maxf^k : ku
3 (f0
1(^k)) = kl
3(l0
1(^k)) = k and ku
2 (f0
1(^k)) = kl
2(l0
1(^k))g,
f00
2 (k) = minf^k : ku
2 (f0
1(^k)) = kl
2(l0
1(^k)) = k and ku
3 (f0
1(^k)) = kl
3(l0
1(^k))g,
l00
2 (k) = maxf^k : ku
2 (f0
1(^k)) = kl
2(l0
1(^k)) = k and ku
3 (f0
1(^k)) = kl
3(l0
1(^k))g.
7. For k = 1;2;:::;p, do as follows.
(a) If f00
3 (k) l00
3 (k), copy vertices pj, j 2 I(k), to processors P(f00
3 (k))
through P(l00
3 (k)).
(b) If f00
2 (k) l00
2 (k)) exists, copy vertices pj, j 2 I(k), to processors
P(f00
2 (k)) through P(l00
2 (k)).
(c) If ku
3 (f0
1(k)) = kl
3(l0
1(k)) and ku
2 (f0
1(k)) = kl
2(l0
1(k)), locally (i.e., in
processor P(k)) compute a maximum element of each A(i), f1(k)
i l1(k).
8. For each A(i) such that kl
2(i) < ku
2 (i) and kl
3(i) < ku
3 (i), do as follows.
(a) Select a median plane m(i) in A(i), and broadcast vertex pm(i) to
every processor.
(b) Determine a maximum entry for plane m(i).
(c) Unless m(i) is the only plane in A(i), replace A(i) by the two sub-
matrices of A(i) consisting of planes lying below or above m(i).
Lemma 2 The s-th phase of Part II takes O(n=pp) time on a square mesh-
connected p-processor multicomputer, if n=p p.
Proof. Steps 1 and 6 take O(n=p) time. The copying of vertices in Steps
2-5 and 7 can be done in O(n=pp) time. In Steps 3, 5 and 7, each processor
rst solves the plane maxima problem in the matrices for which it is responsi-
ble. Then, the largest plane maximum is found. Note that although a single
processor may be responsible for several matrices, the total number of planes,
rows and columns in these matrices is O(n=p). Therefore, these computations
take O(((n=p)log(p=2s 1
)) time.
Consider a matrix A(i) such that kl
2(i) = ku
2 (i) = k and kl
3(i) < ku
3 (i).
Let ^k = kl
1(i). Then neither ku
3 (f0
1(^k)) = kl
3(l0
1(^k)) nor ku
3 (f0
2(k)) = kl
3(l0
2(k))

13
can be true. Therefore, a maximum entry for A(i) is computed in Step 3(b).
Similarly, a maximum entry for a matrix A(i) such that kl
3(i) = ku
3 (i) = k0
and kl
2(i) < ku
2 (i) is computed in Step 5(b).
Next, consider a matrix A(i) such that kl
2(i) = ku
2 (i) = k, kl
3(i) = ku
3 (i) =
k0 and ^k = kl
1(i). Suppose that both ku
3 (f0
1(^k)) = kl
3(l0
1(^k)) and ku
2 (f0
1(^k)) =
kl
2(l0
1(^k)) are false. Since ku
3 (f0
2(k)) = kl
3(l0
2(k)) and ku
2 (f0
3(k0)) = kl
2(l0
3(k0))
cannot both be true, a maximum entry in A(i) is computed in Steps 3(b)
or 5(b). Suppose next that ku
3 (f0
1(^k)) = kl
3(l0
1(^k)) but ku
2 (f0
1(^k)) = kl
2(l0
1(^k))
is false. Then ku
2 (f0
3(k0)) = kl
2(l0
3(k0)) must be false. Therefore, a maximum
entry in A(i) is computed in Step 5(b). Conversely, if ku
3 (f0
1(^k)) = kl
3(l0
1(^k))
is false but ku
2 (f0
1(^k)) = kl
2(l0
1(^k)) is true, then ku
3 (f0
2(k)) = kl
3(l0
2(k)) must be
false, and a maximum entry in A(i) is computed in Step 3(b). Finally, suppose
that both ku
3 (f0
1(^k)) = kl
3(l0
1(^k)) and ku
2 (f0
1(^k)) = kl
2(l0
1(^k)) are true. Then a
maximum entry in A(i) is computed in Step 7(c).
Since the total number of vertices broadcasted in Step 8(a) is at most
p 1, Step 8(a) can be done in O(p) time. The rest of Step 8 is similar to the
computations in Algorithm 4.1 and takes O(n=pp) time. 2
We have not explicitly described how a maximum element of matrix A is
found. Observe, that the largest plane maxima from Part I can be determined
in O(n=p) time by local computation. Similarly, the largest of the (at most
p 1) plane maxima computed in Step 8 of Algorithm 4.2 can also be deter-
mined locally. As for the submatrix maxima computed in Steps 3, 5 and 7
of Algorithm 4.2, it is easy to verify that no processor computes more than
O(n=p) plane maxima per phase. This implies that:
Theorem 3 The maximum-perimeter inscribed triangle problem can be solved
in O(nlogn=pp) time on a square mesh-connected p-processor multicomputer,
if n=p p.
5 Concluding remarks
Although the algorithms that we have presented in this paper di er signi -
cantly in their complexity, they all follow the same basic pattern. In the rst
part of the algorithm, maxima in selected rows or planes are computed. In
Algorithms 3.1 and 3.2, the row maxima are computed simultaneously. In the
algorithm for nding a maximum-perimeter inscribed triangle, the rst part is
divided into O(log(n=p)) phases. Using these maxima, the original matrix is
then subdivided into submatrices. In the second part, we solve (more or less
directly) the (implicit) row or plane maxima problem for the submatrices.
In spite of the simplicity of this pattern, the algorithms (in particular
Algorithms 4.1 and 4.2) are rather complicated. Before a processor can nd
maxima in a submatrix, we must ensure that all vertices required to compute
its entries are stored in the processor. On the other hand, we do not want a
processor to store more than O(n=p) vertices. Thus, complications arise since
we must ensure not only that a processor has the appropriate vertices, but
also that it does not receive vertices from several processors simultaneously.

14
References
1] A. Aggarwal, M.M Klawe, S. Moran, P. Shor, and R. Wilber. Geometric
applications of a matrix searching algorithm. Algorithmica, 2:209{233,
1987.
2] A. Aggarwal and J. Park. Notes on searching in multidimensional mono-
tone arrays. In Proc. 29th Annual IEEE Symposium on Foundations of
Computer Science, pages 497{512, 1988.
3] M.J. Atallah and S.R. Kosaraju. An e cient parallel algorithm for the
row minima of a totally monotone matrix. In Proc. Second Annual ACM-
SIAM Symposium on Discrete Algorithms, pages 394{403, 1991.
4] R. Raman and U. Vishkin. Optimal randomized parallel algorithms for
computing the row minima of a totally monotone matrix. In Proc. 5th An-
nual ACM-SIAM Symposium on Discrete Algorithms (SODA'94), pages
613{621, 1994.
5] P.G. Bradford, R. Fleischer, and M. Smid. More e cient parallel totally
monotone matrix searching. Journal of Algorithms, 23:386{400, 1997.
6] A. Aggarwal, B. Chazelle, L. Guibas, and C. O'Dunlaing. Parallel com-
putational geometry. Algorithmica, 3:293{327, 1988.
7] M.J. Atallah. Parallel techniques for computational geometry. Proc.
IEEE, 80(9):1435{1448, 1992.
8] S.G. Akl and K.A. Lyons. Parallel Computational Geometry. Prentice-
Hall, 1993.
9] F. Dehne, A. Fabri, and A. Rau-Chaplin. Scalable parallel geometric
algorithms for coarse grained multicomputers. In Proc. 9th Annual ACM
Symposium on Computational Geometry, pages 298{307, 1993.
10] O. Devillers and A. Fabri. Scalable algorithms for bichromatic line seg-
ment intersection problems on coarse grained multicomputers. In Algo-
rithms and Data Structures. Third Workshop, WADS'93, pages 277{288,
1993.
11] X. Deng. A convex hull algorithm on coarse grained multiprocessors. In
Proc. 5th Annual International Symposium on Algorithms and Computa-
tion (ISAAC 94), pages 634{642, 1994.
12] F. Dehne, C. Kenyon, and A. Fabri. Scalable and architecture indepen-
dent parallel geometric algorithms with high probability optimal time.
In Proc. 6th IEEE Symposium on Parallel and Distributed Processing
(SPDP), pages 586{593, 1994.
13] F. Dehne, X. Deng, P. Dymond, A. Fabri, and A.A. Khokhar. A random-
ized parallel 3D convex hull algorithm for coarse grained multicomputers.
In Proc. 7th ACM Symposium on Parallel Algorithms and Architectures,
pages 27{33, 1995.

15
14] I. Al-furaih, S. Aluru, S. Goil, and S. Ranka. Parallel construction of
multidimensional binary search trees. In Proc. International Conference
on Supercomputing (ICS'96), 1996.
15] P-O. Fjallstrom. Parallel interval-cover algorithms for coarse grained mul-
ticomputers. Technical Report LiTH-IDA-R-96-39, Dep. of Computer and
Information Science, Linkoping University, 1996.
16] A. Ferreira, C. Kenyon, A. Rau-Chaplin, and S. Ubeda. d-Dimensional
range search on multicomputers. Technical Report 96-23, Laboratoire de
l'Informatique du Parallelisme, Ecole Normale Superieure de Lyon, 1996.
17] P-O. Fjallstrom. Parallel algorithms for batched range searching on
coarse-grained multicomputers. In Proc. 11th Annual Int. Symp. on High
Performance Computing Systems (HPCS'97), pages 167{178, 1997.
18] A. Gibbons and W. Rytter. E cient parallel algorithms. Cambridge
University Press, 1988.
19] A. Pietracaprina, G. Pucci, and J.F. Sibeyn. Constructive deterministic
PRAM simulation on a mesh-connected computer. In 6th Annual ACM
Symposium on Parallel Algorithms and Architectures (SPAA'94), pages
248{61, 1994.
20] V. Kumar, A. Grama, A. Gupta, and G. Karypis. Introduction to Parallel
Computing. The Benjamin/Cummings Publishing Company, Inc., 1994.

cis98006

More Related Content

What's hot (20)

Similar to cis98006 (20)

cis98006