Cascading divide-and-conquer: A technique for designing parallel algorithms

Abstract

We present techniques for parallel divide-and-conquer, resulting in improved parallel algorithms for a number of problems. The problems for which we give improved algorithms include intersection detection, trapezoidal decomposition (hence, polygon triangulation), and planar point location (hence, Voronoi diagram construction). We also give efficient parallel algorithms for fractional cascading, 3-dimensional maxima, 2-set dominance counting, and visibility from a point. All of our algorithms run in O(log n) time with either a linear or sub-linear number of processors in the CREW PRAM model.

Full text

Page 1

Purdue University
Purdue e-Pubs
Computer Science Technical ReportsDepartment of Computer Science
3-9-1987
Cascading Divide-and-Conquer: A Technique for
Designing Parallel Algorithms
Mikhail J. Atallah
Richard Cole
Michael T. Goodrich
This document has been made available through Purdue e-Pubs, a service of the Purdue University Libraries. Please contact epubs@purdue.edu for
additional information.
Atallah, Mikhail J.; Cole, Richard; and Goodrich, Michael T., "Cascading Divide-and-Conquer: A Technique for Designing Parallel
Algorithms" (1987).Computer Science Technical Reports.Paper 576.
http://docs.lib.purdue.edu/cstech/576

Page 2

CASCADING DIVIDE-AND CONQUER:
A TECHNIQUE FOR DESIGNING
PARALLEL ALGORITHMS
Mikhail I. A!llIJah
Richard Cole
Michael T. Goodrich
CSD-1R-665
MJn<h 1987
(Revised June 1989)

Page 3

SIAM J
\01.
( " ~ " ' l ' r
I ~ .
/'<0..J. 1'1'
4 ~ ~ _ 5 . l ~ .
lone
1 < I ~ < 1
(.
I ' I ~ " S",c.e", rnf
1 " < l u , , , , ~ 1 a"d 1\1'1'1,<<1 M,,,he,,,.,,,c<
( ~ ' b
CASCADING DIYIDE-AND-CONQUER: A TECHNIQUE FOR
DESIGNING PARALLEL ALGORITHMS'
MIKHAIL J. ATALLAHt. RICHARD COLEt. AND MICHAEL T. GOODRICH§
AbSlracl. T<:chniqucs for parallt:l divide-and-conquer are presenled. rcsulting in improved parallel
:lIgorjthms for a number of probl<:ms. The problems for which improved algorithms are gi\'cn include
5cg.menL inlcrscctlon detection. trapezoidal decomposition. and planar point location. Efficient parallel
algorithms ilre algo given for fraclional cascading. lhree·dimensional maxima. lwo-set dominancc counting.
and visibility from a point. All of the algorithms presenled run in O(log n) lime with either a linear or a
sublinear number of proccssors in the CREW PRAM model.
K e ~ ' words. parallel algorithms. parallel data structures, divide-and-conquer. computational geometry.
fraclional cascading. visibility. planar point locat;on. trapezoidal decomposition. dominance, lnlersection
deteCllon
AMS(MOS) subject ci:l.ssil1cations. 68E05, 68C05. 68C15
l. Intl'oduction. This paper presents a number of genel'al techniques for parallel
divide-and-conquer. These techniques are based on nontrivial generaliza[ions ofCole's
recent parallel merge son resulI r13] and enable us [Q achieve improved complexi[y
bounds for a large number o( pl'Oblems_ In panicular, our [echniques can be applied
[0 any problem solvable by a divide-and-conquer method such that the subproblem
merging step can be implemented using a restl'icted, but powerful, set of opemtions,
which include (i) merging soned lists, (ii) computing the values of labeling functions
on elements stored in soned lis[s, and (iii) changing the idemi[y ofelemems in a soned
list monoronically. The elements slOl'ed in such sorted lists need not belong to a total
ordel', so long as the compu[ation can be specified so that we will never try to compal'e
two incomparable elemems. We demonstrate the power of these techniques by using
[hem to design efficient parallel algorithms for solving a number of fundamental
problems from computational geomeuy.
The general framework is one in which we want
algorithms for the CREW PRAM or EREW PRAM models_ Recall that the CREW
PRAM model is the synchronous shared memory model in which processors may
simultaneously read from any memory location but simultaneous writes are nO( allowed.
The EREW PRAM model does not allow for any simultaneous access to a memory
cell. Our goal is La find algol'ithms [hat run as fast as possible and are efficient in the
following sense: if p(n) is the processor complexity, 1('1) the parallel time complexi[y,
and seq( n) the time complexity of the best-known sequemial algorithm for the problem
[Q design efficient parallel
* Recei\'ed by lhe editors September 14. 1987: accepted for publication (in revised form) August 12,
1988. This paper appeared in preliminary form as [3] and as ponions of [17].
-:- Depanmenl of Computer Science, Purdue University, West Lafayetle. Indiana 47907. The research
oflhis author was supponed by the Office of Na\'al Research under grants NOOO14·84-K-0502 and NOOO14-.86-
K-0689, and by the National Science Foundallon under grant DCR-84-51393. with matching funds from
AT&T.
~ Courant Instilute. New York University. New York. New York 10012. Thc research of Ihis author
was supponed in pan by National Science Foundation grants DCR·84-0I633 and CCR-870:!:!71. and by
an Office of Naval Research granl NOOOI4.85-K-0046.
§ Depanmenl ofComputerScience.Johns Hopkins Universily, Baltimore. Maryland 21218.The research
of lhis author was supponed by Office of Naval Research grants NOOOI4-84.K_0502 and NOOO-86.K-0689.
NaLional Science Foundation grants DCR-84-.51393. with matching funds from AT&T. and CCR-88-10568.
and a David Ross grant from lhe Purdue Research Foundalion.

Page 4

500
1'01, J. ATALLAH. R_ COLE. AND M. T- GOODRICH
under considermion. then t( 11) '" p(n) = O(seq( /l)). If the product 1(/1) of' p(,1) achieves
the sequential lower bound for the problem, then we say the algorithm is optimal.
When specifying the processor complexity. we omil the "big oh," C.g., we say "11
processors" rather than "O(n) processors"; this is justified because we can always
save a constant facwr in the number of processors at a cost orthe same conSlanl factor
in the running lime. In all of [he problems listed below, we achieve ten) = D(log n)
and, simultaneously (except for planar point locationl. an optimal ten) * p(n),
Previous work on parallel divide·and-conquer has produced relatively few
algorithms Lhar are optimal in the above sense. Exceptions to this include some of the
previous algorithms for the convex huU problem [1], [4J, [6J, [18J, [27J and the problem
of circumscribing a convex polygon with a minimum-area triangle [IJ. Unfortunately,
each of these approaches was very problem-specific. Thus, there is a need for techniques
of wider scope.
This is in fact the mOlivation for our work, for we give a number of general
techniques for efficiently solving problems in parallel by divide-and-conquer. We model
the divide-and-conquer paradigm as a binary tree whose nodes contain sorted lists of
some kind. The compmation involves compming on this tree in a recursively defined
bOHom-up fashion using lists of items and labeling functions defined for each node
in the tree. In Cole's scheme [13J, (he list at a node was defined to be the sorted merge
of the two lists stored at its children. In our scheme. however, the lists at a node of
the tree can depend on the lists 13f its children in more complex ways. For example,
in our solution to the segmem inTersection deteCTion problem, the lists at a node depend
on computing, in addition to merges. set difference operations thal are not directly
solvable by the "cascading" method used by Cole [13]. Such operations arise here
becausc the lists at a node comain segments ordered by their intersections with a
vertical line (the so-called "above" relationship). which is obviously not a total order.
One may be tcmpted to try to solve this problem by delaying the performance of these
set difference operations unIii the end of the compmarion. Unfortunately, this is not
feasible for many reasons, not the least of which is that this approach could lead to
a situation in which a processor tries to compare two incomparable items. Nor does
it seem possible to explicitly perform the set difference operations on-line without
sacrificing the time-efficiency of the cascading method. Our solUlion avoids both of
these problems by using an on-line "identity-changing" technique.
Another significant contribution of this paper is an optimal parallel construction
of the "fractional cascading" data structure of Chazelle and Guibas [11]. This too is
based on a generalization of Cole's method [I3J in the sense that instead of having
the computation proceeding up and down a tree, it now moves around a directed
graph (possibly with cycles). Our solution to fractional cascading is quice different
from the sequential method of Chazelle and Guibas (their method relies on an
amortization scheme [0 achieve a linear running time L
The following is a list of the problems for which our techniques result in improved
complexity bounds. Unless otherwise specified, each performance bound is expressed
as a pair (((n),p(n)), where ten) and pen) are the time and processor complexities,
respectively, in [he CRE\-\' PRAM model.
Fractional cascading. Given a directed graph G = (V, E), such that every node U
contains a soned list C(u), construct a data structure that, given a walk (VI, U:!,' .. , um)
in G and an arbitrary element x, enables a single processor 10 locate x quickly in each
C(v,), where f1=IVI+!EI+2:,.",vIC(v)!. In [I:!J Chazelle and Guibas gave an elegant
0(,1) time, 0(11) space, sequential construction, where n = ~
(log 11, n/log n) conscruction.
•.cv IC(u)l. We give a

Page 5

CASCfl.DI NG DIVI DE_A Nf).CONQUER
501
Trape=oidal decomposition. Given a set S of II line seg.ments in the planc, detcrmine
for each segment endpoint p the firsr segment "stabbed'" by the verrical ray emanating
upward (and downward) from p. A ( I o g ~
rl, II) solution [Q this problem was given by
Aggarwal et al. in [I], later improved [Q (log 11 log log n, n) by Atallah and Goodrich
in [5J. We improve this [Q (log tI, n).
Planar poim locatioll. Given a subdivision of the plane inlo (possibly unbounded)
polygons, construct, in parallel, a data structure that, once buill, enables one processor
to determine for any query point p lhe polygonal face containing p. Let Q(1I) denote
the lime for performing such a query, where n is the number of edge segments in the
subdivision. A ( I o g ~
11, 11), Q(II) = O ( [ o g ~
,,) solurion was given by Aggarwal et al. in
[I], lalcr improved Lo (log '1 log log 11, n), Q(II) = O(log n) by Atallah and Goodrich
in [5J. In [14J Dadoun and Kirkpatrick further improved this to (log n log* 11, r1),
0(11) = O(log /I). We give a (log n, 11), Q(n) = O(log 11) solution.
Segment inrerseclion detection. Given a sel 5 of n line segments in rhe plane,
determine if any two segments in S intersect. A ( I o g ~ n, n) solution was given in [IJ,
laler improved to (log 11 log log n, n) in [5J. We improve this to (log 11, tl).
Three-dimensional maxima. Given a set 5 of n points in rhree-dimensional space,
determine which points are maxima. A maximum in S is any point p such that no
other point of S has x,)', and z coordinates that simultaneously exceed rhe correspond-
ing coordinates of p. A (log n log log", II) solution was given in [5]. We improve this
La (log", Ill.
.
TH.·o-sef dominance coutlting. Given a set A = {qt, q2,' .. , q,} and a set B =
{rl' r2, ••• ,rn!} of points in the plane, determine for each point riin B the number of
points in A whose x and.iI coordinares are both less than the corresponding coordinates
of rio The problem size is n = 1+ m. A (log n log log n, ") solution was given in [5]. We
improve this La (log n, nl.
Visibility Ironl a point. Given" line segments such that no tWO intersecr (except
possibly at endpoints) and a point p, determine thaI pan of the plane visible from p.
if all rhe segments are opaque. A (log" log log 11, n) solution was given in [5]. We
improve this to (log n, n).
We recemly learned that Reifand Sen [24J sol ved planar point location, trapezoidal
decomposition, segment intersection and visibilily in randomized O(log n) time using
O(n) processors in the CREW PRAM model. All of our algorithms are deterministic.
This paper is organized as follows. In § 2 we present a generalized version of the
cascading merge procedure and in § J we give our method fordoing fractional cascading
in parallel. In § 4 we show how to apply the fractional cascading rechnique [Q a data
structure we call the plane sweep tree, showing how to solve the trapezoidal decomposi-
tion and point location problems. In § 5 we show how to exrend the cascading merge
technique to allow for cascading in the "above" panial order of line segments. giving
solutions to the problems of building the plane sweep tree and solving the intersection
derection problem. In § 6 we use the cascading divide-and-conquer rechnique lO
compute labeling functions and show how to use this approach to solve three-
dimensional maxima, two-ser dominance couming, and visibility from a point. Finally,
in § 7, we briefly describe how mosl of our algorithms can be implemented in the
EREW PRAM model with the same time and processor bounds as our CREW PRAM
algorithms, and we conclude in § 8.
2. A generalized cascading merge procedure. In this section we presenL a technique
for a generalized version of the merge soning problem. Suppose we are given a binary
lree T (nOl necessarily complete) with irems, taken from some lOral order, placed at