Faster output-sensitive parallel algorithms for 3D convex hulls and vector maxima

Abstract

In this paper we focus on the problem of designing very fast parallel algorithms for the convex hull and the vector maxima problems in three dimensions that are output-size sensitive. Our algorithms achieve $\text{O(}\text{log}\text{log}{}^2\text{n}\text{log}\text{h)}$ parallel time and optimal $\text{O(n}\text{log}\text{h)}$ work with high probability in the CRCW PRAM where n and h are the input and output size, respectively. These bounds are independent of the input distribution and are faster than the previously known algorithms. We also present an optimal speed-up (with respect to the input size only) sublogarithmic time algorithm that uses superlinear number of processors for vector maxima in three dimensions.

Introduction

The study of algorithms is mainly concerned with developing algorithms for well-defined problems that are close to the best-possible (for the problem at hand). The most common measure of the performance of an algorithm is related to the running time of the algorithm. For any non-trivial problem, the running time of an algorithm increases monotonically with the size of the input. Hence the efficiency of an algorithm is usually measured as a function of the input-size. However, for many geometric problems, additional parameters like the size of the output capture the complexity of the problem more accurately enabling us to design superior algorithms. Algorithms whose running times are sensitive to the output-size have been actively pursued for problems like convex hulls [Cha95], [CM92], [CS89], [Mat92], [Sei86].

The primary objective of designing parallel algorithms is to obtain very fast running time while keeping the total work (the processor-time product) close to the best sequential algorithms. Problems for which output-size sensitive algorithms are known, it becomes especially important to have similar parallel algorithms. Unless we design parallel algorithms that are output-sensitive, the corresponding (output-sensitive) sequential may be faster for many instances. (We will often use the shorter term output-sensitive instead of output-size sensitive.)

The task of designing output-size sensitive algorithms on parallel machines is even more challenging than their sequential counterparts. Not only is the output-size an unknown parameter, we also have to rapidly eliminate input points that do not contribute to the final output without incurring a high cost. The divide-and-conquer method is not directly effective as it cannot divide the output evenly—in fact herein lies the crux of the difficulty in designing ‘fast’ output-sensitive algorithms. By ‘fast’ we imply $\text{O(}\text{log}\text{h)}$ or something very close, where h is the output size. The sequential output-size sensitive algorithms often use techniques like gift wrapping or incremental construction which are inherently sequential.

The parallel random access machine (PRAM) has been the most popular model for designing algorithms because of its close relationship with the sequential models. For example if S(n) is the best-known sequential time complexity for the input size n then we aim for a parallel algorithm with P(n) processors and T(n) running time so as to minimize T(n) subject to keeping the product P(n)·T(n) close to O(S(n)). A parallel algorithm that actually does total work O(S(n)) is called a work optimal algorithm. Simultaneously, if one can also match the time lower bound then the algorithm is the best possible (theoretically).

The fastest possible time bound clearly depends on the parallel machine model. For example, in the case of concurrent read exclusive write (CREW) PRAM model, the convex hull cannot be constructed faster than $\text{Ω(}\text{log}\text{n)}$ time, because of an $\text{Ω(}\text{log}\text{n)}$ bound for computing the maximum (minimum). Note that this bound is independent of the output-size. However, this bound is not applicable to the CRCW model. For parallel algebraic decision tree model, Sen [Sen97] has obtained a trade-off between the number of processors and possible speed-up for a wide range of problems in computational geometry. For convex hulls, the following is known.

Lemma 1.1 Sen [Sen97]

Any randomized algorithm in the parallel bounded degree decision tree model for constructing convex hull of n points and output-size h, has a parallel time-bound of $\text{Ω(}\text{log}\text{h/}\text{log}\text{k)}$ using kn processors, k>1, in the worst case.

In other words, for super-linear number of processors, a proportional speed-up is not achievable and hence these parallel algorithms cannot be considered efficient. The best or the ultimate that one can hope for under the circumstances is an algorithm that achieves $\text{O(}\text{log}\text{h)}$ time using n processors.

Our algorithms are designed for the CRCW PRAM model. Although we always work in a Euclidean space $\text{E}{}^{\mathrm{d}}$ we are mainly interested in the combinatorial complexity of the algorithm. We pretend that a single memory location can hold a real number and a processor can perform an arithmetic operation involving real numbers in a single step. In reality there may be numerical errors due to finite word lengths that we ignore. This is a non-trivial issue and deserves a separate treatment. This model is consistent with the model that is used for sequential computational geometry, called ‘Real’-RAM. For our randomized algorithms, we further assume that processors have access to $\text{O(}\text{log}\text{n)}$ random bits in constant time.

Convex polygons are very important objects in computational geometry, and in a large number of cases give rise to very efficient algorithms because of their nice property, namely convexity.

Definition 1.1

Given a set S={p₁,p₂,…,p_n} of n points in $\text{E}{}^{\mathrm{d}}$ (the Euclidean d-dimensional space), the convex hull of S is the smallest convex polytope containing all the points of S. The convex hull problem is to determine the ordered list CH(S) of the points of S defining the boundary of the convex hull of S.

In two dimensions, the ‘ordering’ in the output is simply the clockwise (or counter-clockwise) ordering of the vertices of the hull. In three dimensions it can be the cyclic ordering of the hull edges around each hull vertex.

The problem of constructing convex hulls has attracted a great deal of attention from the inception of computational geometry. In three dimensions, Preparata and Hong [PH77], described the first $\text{O(n}\text{log}\text{n)}$ time algorithm. Clarkson and Shor [CS89] presented the first (randomized) optimal output-sensitive algorithm which ran in $\text{O(n}\text{log}\text{h)}$ expected time, where h is the number of hull vertices. Their algorithm was subsequently derandomized optimally by Chazelle and Matoušek [CM92]. Chan [Cha95] presented a very elegant approach for output-sensitive construction of convex hulls using ray shooting that achieve optimal $\text{Θ(n}\text{log}\text{h)}$ running times for dimensions two and three. In higher dimensions, the quest is still on to design optimal output-sensitive algorithms. Recently, Chan [Cha95] designed an output-sensitive algorithm for convex hulls in d dimensions which runs in $\text{O(n}\text{log}{}^{\mathrm{O(1)}}\text{h+h}{}^{\mathrm{\lfloor d/2\rfloor }}\text{)}$ time. Seidel [Sei86] computes F faces of the convex hull of n points in a fixed dimension d in $\text{O(n}{}^2\text{+F}\text{log}\text{n)}$ time. This can be slightly improved to $\text{O(n}{}^{\mathrm{2-(2/(\lfloor d/2\rfloor +1))+\epsilon }}\text{+F}\text{log}\text{n)}$, for any fixed ε>0, using a technique of Matoušek [Mat92]. In a recent paper, Amato and Ramos [AR96] have shown that the convex hull of n points in $\text{R}{}^{\mathrm{d+1}}\text{,}\text{2⩽d⩽4}$, can be computed in $\text{O((n+F)}\text{log}{}^{\mathrm{d-1}}\text{F)}$ time.

In the context of parallel algorithms, for convex hulls in three dimensions (3-D hulls) Chow [Cho80] described an $\text{O(}\text{log}{}^3\text{n)}$ time algorithm using n CREW processors. An $\text{O(}\text{log}{}^2\text{n}\text{log}{}^{\mathrm{\ast }}\text{n)}$ time algorithm using n processors was obtained by Dadoun and Kirkpatrick [DK89] and an $\text{O(}\text{log}{}^2\text{n)}$ time algorithm was designed by Amato and Preparata [AP92]. Reif and Sen [RS92] presented an $\text{O(}\text{log}\text{n)}$ time and $\text{O(n}\text{log}\text{n)}$ work randomized algorithm which was the first-known worst-case optimal algorithm for three-dimensional hulls in the CREW model. Their algorithm deals with the dual equivalent of the convex hull problem namely the intersection of half-spaces in three dimensions. The algorithm works on a divide-and-conquer approach. It works in $\text{O(}\text{log}\text{n)}$ phases pruning away the redundant half-spaces and keeping the work to linear in each phase. This algorithm was derandomized by Goodrich [Goo93] who obtained an $\text{O(}\text{log}{}^2\text{n)}$ time, $\text{O(n}\text{log}\text{n)}$ work method for the EREW PRAM. In the context of output-size sensitive algorithm, one faces the problem of dividing the output points evenly so that one can finish in $\text{O(}\text{log}\text{h)}$ phases, keeping the work linear in each phase, especially when the output-size is not known. In [GS97], the authors have shown that the convex hulls in two dimensions can be constructed in $\text{O(}\text{log}\text{log}\text{n}\text{log}\text{h)}$ time with optimal work with high probability. In three dimensions, Goodrich and Ghouse [GG91] described an $\text{O(}\text{log}{}^2\text{n)}$ expected time, $\text{O(}\text{min}\text{{n}\text{log}{}^2\text{h,n}\text{log}\text{n})}$ work method, which is output-sensitive but not work-optimal. More recently, Amato et al. [AGR94] gave a deterministic $\text{O(}\text{log}{}^3\text{n)}$ time, $\text{O(n}\text{log}\text{h)}$ work algorithm for convex hulls in $\text{R}{}^3$ on the EREW PRAM.

In higher dimensions, Amato et al. [AGR94] have shown that the convex hull of n points in $\text{R}{}^{\mathrm{d}}$ can be constructed in $\text{O(}\text{log}\text{n)}$ time with $\text{O(n}\text{log}\text{n+n}{}^{\mathrm{\lfloor d/2\rfloor }}\text{)}$ work with high probability and in $\text{O(}\text{log}\text{n)}$ time with $\text{O(n}{}^{\mathrm{\lfloor d/2\rfloor }}\text{log}{}^{\mathrm{c(\lceil d/2\rceil -\lfloor d/2\rfloor )}}\text{n)}$ work deterministically, where c>0 is a constant.

In this paper, we present a randomized algorithm for the convex hulls in three dimensions that is faster for all output-sizes while maintaining the optimal output-sensitive work bound. The algorithm exploits an observation of Clarkson and Shor [CS89], namely, that of iterative pruning of non-extreme points. We also make use of a number of sophisticated techniques like bootstrapping and super-linear processors parallel algorithms for convex hulls [Sen97] combined with a very fine-tuned analysis.

Let T be a set of vectors in $\text{R}{}^{\mathrm{d}}$. The partial order ⩽_M is defined for two vectors x=(x₁,x₂,…,x_d) and y=(y₁,y₂,…,y_d) as follows: x⩽_My (x is dominated by y) if and only if x_i⩽y_i for all 1⩽i⩽d.

Definition 1.2

A vector v∈T is said to be maximal if it is not dominated by any other vector w∈T. The problem of maximal vectors is to determine all maximal vectors in a given set of input vectors.

Relatively little work has been done in the context of parallel algorithms for the vector maxima problem. Efficient sequential algorithms are known for two and three dimensions (the $\text{O(n}\text{log}\text{n)}$—time algorithm is worst case optimal). However, for $\text{h∈o(}\text{log}\text{n)}$ (h is the number of vertices on the hull) a better (O(nh) time) algorithm can be easily obtained in two dimensions by finding the point with maximum y coordinate, deleting all the points dominated by it and repeating on the reduced problem. This algorithm takes linear time for constant h. Kirkpatrick and Seidel presented an $\text{O(n}\text{log}\text{h)}$ time algorithm and showed that the bound is tight with respect to the input and the output sizes [KS86]. In the context of parallel algorithms for two dimensions, an $\text{O(}\text{log}\text{n)}$ time optimal algorithm can be obtained easily by using any of the $\text{(n,}\text{log}\text{n)}$ algorithm for sorting followed by a straight forward divide-and-conquer. The best-known result for three-dimensional maxima is $\text{O(}\text{log}\text{n)}$ time and $\text{O(n}\text{log}\text{n)}$ operations due to Atallah et al. [ACG89] in which they have used parallel merging techniques. Using the techniques of [GS97] an $\text{O(}\text{log}\text{log}\text{n}\text{log}\text{h)}$ time, optimal work algorithm can be obtained for vector maxima in two dimensions also. We present an algorithm for vector maxima in three dimensions.

Our algorithms are randomized and always provide correct output and the bounds (running time) hold with high probability independent of the input distribution. Such algorithms are often referred to as Las Vegas algorithms. The term high probability implies probability exceeding 1−1/n^c for any predetermined constant c where n is the input-size. We will use the notation $\text{O}\text{̃}$ instead of O to denote that the bound holds with high probability.

Our algorithms achieve $\text{O(}\text{log}\text{log}{}^2\text{n}\text{log}\text{h)}$ time with optimal $\text{O(n}\text{log}\text{h)}$ work with high probability. This is one of the first non-trivial applications of super-linear processor algorithms in computational geometry to obtain speed-up for a situation where initially there is no processor advantage. Our work establishes a close connection between fast output-sensitive parallel algorithms and super-linear processor algorithms. Consequently, our algorithms become increasingly faster than the previous algorithms as the output size decreases. We are not aware of any previous work where the parallel algorithms speed-up optimally with the output size in the sublogarithmic time domain.

We also present an optimal speed-up (with respect to the input size only) sublogarithmic time algorithm that uses super-linear number of processors for vector maxima in three dimensions.