Showing papers by "Michael T. Goodrich published in 1993"

External-memory computational geometry

Abstract: In this paper we give new techniques for designing efficient algorithms for computational geometry problems that are too large to be solved in internal memory. We use these techniques to develop optimal and practical algorithms for a number of important large-scale problems. We discuss our algorithms primarily in the context of single processor/single disk machines, a domain in which they are not only the first known optimal results but also of tremendous practical value. Our methods also produce the first known optimal algorithms for a wide range of two-level and hierarchical multilevel memory models, including parallel models. The algorithms are optimal both in terms of I/O cost and internal computation. >

Geometric partitioning made easier, even in parallel

Abstract: We present a simple approach for constructing geometric partitions in a way that is easy to apply to new problems. We avoid the use of VC-dimension arguments, and, instead, base our arguments on a notion we call the scaffold dimension, which subsumes the VC-dimension and is simpler to apply. We show how to easily construct (1/r)-nets and (1/r)-approximations for range spaces with bounded scaffold dimension, which immediately implies simple algorithms for constructing (1/r)-cuttings (by straight-forward recursive subdivision methods). More significant than simply being a conceptual simplification of previous approaches, however, is that our methods lead to asymptotically faster and more-efficient EREW PRAM parallel algorithms for a number of computational geometry problems, including the development of the first optimal-work NC algorithm for the well-known 3-dimensional convex hull problem, which solves an open problem of Amato and Preparata. Interestingly, our approach also yields a faster sequential algorithm for the distance selection problem, by the parametric searching paradigm, which solves an open problem posed by Agarwal, Aronov, Sharir, and Suri, and reiterated by Dickerson and Drysdale.

Area-efficient upward tree drawings

Abstract: Rooted trees are usually drawn planar and upward, i.e., without crossings and with parents placed above their children. In this paper we investigate the area requirement of planar upward drawings of trees, and present optimal algorithms for constructing such drawings.

Dynamic ray shooting and shortest paths via balanced geodesic triangulations

Abstract: of Results TVe give new methods for maintaining a data structure that supports ray shooting and shortest path queries in a dynamically-changing connected subdivision S. Our approach is based on a new dynamic method for maintaining a balanced decomposition of a simple polygon via geodesic triangles. We maintain such triangulations by viewing their dual trees as balanced trees. We show that rotations in these trees can be implemented via a simple “diagonal swapping” operation performed on the corresponding geodesic triangles, and that edge insertion and deletion can be implemented on these trees using operations akin to the standard split ancl splice operations. We also maintain a dynamic point location structure on the geodesic triangulation, so that we may implement ray shooting queries by first locating the ray’s endpoint and then walking along the ray from geodesic triangle to geodesic triangle until we hit the boundary of some region of S. The shortest path between two points in the same region is obtained by locating the two points and then walking from geodesic triangle to geodesic triangle either following a boundary or taking a shortcut through a common tangent. Our data structure uses 0(72) space and supports queries and updates in 0(log2 n) time, where n is the current size of S. It outperforms the previous best data structure for this problem by a log n factor in all the complexity measures (space, query times, and update times).

Geometric Pattern Matching Under Euclidean Motion.

Abstract: Given two planar sets A and B, we examine the problem of determining the smallest ϵ such that there is a Euclidean motion (rotation and translation) of A that brings each member of A within distance ϵ of some member of B. We establish upper bounds on the combinatorial complexity of this subproblem in model-based computer vision, when the sets A and B contain points, line segments, or (filled-in) polygons. We also show how to use our methods to substantially improve on existing algorithms for finding the minimum Hausdorff distance under Euclidean motion.

Constructing the Voronoi diagram of a set of line segments in parallel

Abstract: In this paper we give a parallel algorithm for constructing the Voronoi diagram of a polygonal scene, i.e., a set of line segments in the plane such that no two segments intersect except possibly at their endpoints. Our algorithm runs inO(log2n) time usingO(n) processors in the CREW PRAM model.

Constructing arrangements optimally in parallel

Abstract: We give two optimal parallel algorithms for constructing the arrangement ofn lines in the plane. The first nethod is quite simple and runs inO(log2n) time usingO(n2) work, and the second method, which is more sophisticated, runs inO(logn) time usingO(n2) work. This second result solves a well-known open problem in parallel computational geometry, and involves the use of a new algorithmic technique, the construction of an ?-pseudocutting. Our results immediately imply that the arrangement ofn hyperplanes in ?d inO(logn) time usingO(nd) work, for fixedd, can be optimally constructed. Our algorithms are for the CREW PRAM.

Parallel algorithms column 1: models of computation

Abstract: If you are the type that always orders vanilla in the ice cream shop, then you should probably sta y away from parallel algorithm design, for you may never get past the fact that any given paralle l algorithm may be designed for any one of several different computational models . If, on the other hand, you are the type who thinks there are still not enough channels on cable TV, then you migh t think the number of parallel models is woefully small . If you fall into neither camp, which, accordin g to the Chernoff bounds [22], you probably should, then you may find this first SIGACT News column on parallel algorithm design of some use . For here I review a \"classic\" model for parallel computatio n and I survey some interesting work on alternative models for parallel computation .

P-complete geometric problems

Abstract: In this paper we show that it is impossible to solve a number of “natural” two-dimensional geometric problems in polylog time with a polynomial number of processors (unless P=NC). Thus, we disprove a popular belief that there are no natural P-complete geometric problems in the plane. The problems we address include instances of polygon triangulation, planar partitioning, and geometric layering. Our results are based on non-trivial reductions from the monotone circuit value and planar circuit value problems.

Output-sensitive methods for rectilinear hidden surface removal

Abstract: We present an algorithm for the hidden-surface elimination problem for rectangles, which is also known as window rendering. The time complexity of our algorithm is dependent on both the number of input rectangles, n, and on the size of the output, k. Our algorithm obtains a trade-off between these two components, in that its running time is O(r(n1+1/r + k)), where 1 ≤ r ≤ log n is a tunable parameter. By using this method while adjusting the parameter r "on the fly" one can achieve a running time that is O(n log n + k(log n/log(1+k/n))). Note that when k is Θ(n), this achieves an O(n log n) running time, and when k is Θ(n1+ϵ) for any positive constant ϵ, this achieves an O(k) running time, both of which are optimal.

External-Memory Computational Geometry (Preliminary Version)

Abstract: In this paper we give new techniques for designing e cient algorithms for computational geometry problems that are too large to be solved in internal memory. We use these techniques to develop optimal and practical algorithms for a number of important largescale problems. We discuss our algorithms primarily in the context of single processor/single disk machines, a domain in which they are not only the rst known optimal results but also of tremendous practical value. Our methods also produce the rst known optimal algorithms for a wide range of two-level and hierarchical multilevel memory models, including parallel models. The algorithms are optimal both in terms of I/O cost and internal computation.

Point Probe Decision Trees for Geometric Concept Classes

Abstract: A fundamental problem in model-based computer vision is that of identifying to which of a given set of concept classes of geometric models an observed model belongs. Considering a “probe” to be an oracle that tells whether or not the observed model is present at a given point in an image, we study the problem of computing efficient strategies (“decision trees”) for probing an image, with the goal to minimize the number of probes necessary (in the worst case) to determine in which class the observed model belongs. We prove a hardness result and give strategies that obtain decision trees whose height is within a log factor of optimal.

Blocking for external graph searching

Abstract: In this paper, we consider the problem of using disk blocks efficiently in searching graphs that are too large to fit in internal memory. Our model allows a vertex to be represented any number of times on the disk in order to take advantage of redundancy. We give matching upper and lower bounds for complete d-ary trees and d-dimensional grid graphs, as well as for classes of general graphs that intuitively speaking have a close to uniform number of neighbors around each vertex. We also show that for the special case of grid graphs blocked with isothetic hypercubes, there is a provably better speed-up if even a small amount of redundancy is permitted.

Biased Finger Trees and Three-Dimensional Layers of Maxima

Abstract: Kumar Ramaiyert Dept. of Computer Science Johns Hopkins University Baltimore, MD 21218-2694 kumarlDcs . j hu. edu We present a. method for maintaining biased search trees so as to support fast finger updates (i.e., updates in which one is given a pointer to the part of the hee being changed). We illustrate the power of such biased finger trees by showing how they can be used to derive an optimal O(n log n) algorithm for the 3-dimcnsionallayers-of-maxima problem and also obtain an improved method for dynamic point location.

Approximate parallel prefix computation and its applications

Abstract: The authors address two fundamental problems in parallel algorithm design-parallel prefix sums and integer sorting-and show that both of them can be approximately solved very quickly on a randomized CRCW PRAM. In the case of prefix sums the approximation is in terms of the accuracy of the sums and in the case of integer sorting it is in terms of allowing some gaps between consecutive elements in the ordered list. By introducing approximation in these ways the authors are able to solve these problems in o(lg lg n) time, and thus avoid the near-logarithmic lower bounds by Beame and Hastad that hold for the exact versions of these problems. Nevertheless, they demonstrate that these approximations are strong enough to be used as subroutines in fast randomized algorithms for some well-known problems in parallel computational geometry. Perhaps the most succinct way to describe the power of the new tools which are presented is by observing that prior to this work it was known how to solve the interval allocation problem fast. The authors show how to solve the ordered version of the problem. >

Constructing the convex hull of a partially sorted set of points

Abstract: In this paper we give an optimal algorithm for constructing the convex hull of a partially sorted set S of n points in R 2 . Specifically, we assume S is represented as the union of a collection of non-empty subsets S 0 , S 1 , S 2 ,…, S m , where the x -coordinate of each point in S i is smaller than the x -coordinate of any point in S j if i j . Our method runs in O( n log h max ) time, where h max is the maximum number of hull edges incident on the points of any single subset S i . In fact, if one is only interested in finding the hull edges that ‘bridge’ different subsets, then our method runs in O( n ) time.

An addendum to parallel methods for visibility and shortest-path problems in simple polygons

Abstract: In [-3] Rfib observes that the p roof of L e m m a 5.1 f rom [2] is incomplete. In this note we show how to complete this proof. We assume the reader is familiar with [2-1. The difficulty arises in the me thod for finding all type 2 and type 3 intersections for a segment s = ~ f rom A in a slab I I v, when p e 1-Iv, but q is not in 1-Iv, where we assume, wi thout loss of generality, that x(p)< x(q) (for the other case is symmetric). Let w be v's sibling. There are two cases:

Experimental evidence for the power of random sampling in practical parallel algorithms

Abstract: Recent results in parallel algorithm theory have shown random sampling to be a powerful technique for achieving efficient bounds on the expected asymptotic running time of parallel algorithms for a number of important problems. The authors show experimentally that randomization is also a powerful practical technique in the design and implementation of parallel algorithms. Random sampling can be used to design parallel algorithms with fast expected run times, which meet or beat the run times of methods based on more conventional methods for a variety of benchmark tests. The constant factors of proportionality in the run times are small, and, most importantly, the expected work (and hence running time) avoids worst cases due to input distribution. They justify the approach through experimental results obtained on a Connection Machine CM-2 for a specific problem, namely, segment intersection reporting, and explore the effect of varying the parameters of the method. >