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

Dynamic trees and dynamic point location

Abstract: This paper describes new methods for maintaining a point-location data structure for a dynamically changing monotone subdivisionS. The main approach is based on the maintenance of two interlaced spanning trees, one forS and one for the graph-theoretic planar dual ofS. Queries are answered by using a centroid decomposition of the dual tree to drive searches in the primal tree. These trees are maintained via the link-cut trees structure of Sleator and Tarjan (J. Comput. System Sci., 26 (1983), pp. 362{381), leading to a scheme that achieves vertex insertion/deletion in O(logn) time, insertion/deletion of k-edge monotone chains in O(logn+k) time, and answers queries in O(log 2 n) time, with O(n) space, where n is the current size of subdivision S. The techniques described also allow for the dual operations expand and contract to be implemented in O(logn) time, leading to an improved method for spatial point location in a 3-dimensional convex subdivision. In addition, the interlaced-tree approach is applied to on-line point location (where one builds S incrementally), improving the query bound to O(logn log logn) time and the update bounds to O(1) amortized time in this case. This appears to be the rst on-line method to achieve a polylogarithmic query time and constant update time.

Using approximation algorithms to design parallel algorithms that may ignore processor allocation

Abstract: A framework is presented for designing parallel algorithms that may ignore processor allocation. A number of fast approximation algorithms are developed, and it is shown how to use these algorithms to simulate any algorithm that fits this framework in a work-preserving fashion on a randomized CRCW PRAM. Several applications of the approach to parallel computational geometry are given. >

Intersecting line segments in parallel with an output-sensitive number of processors

Abstract: An efficient parallel algorithm is given for constructing the arrangement of n line segments in the plane, i.e., the planar graph determined by the segment endpoints and intersections. This algorithm is efficient relative to three efficiency measures—it is an NC algorithm, it has a small time-processor product, and it is output-size sensitive. In particular, it runs in $O(\log n)$ time using $O(n\log n + k)$ processors, where k is the size of the output (which is $\Omega (n^2 )$ in the worst case). The algorithm does not receive the value of k as input, it determines it on-line. A method or solving an important special case of the segment arrangement problem is also shown, namely, when each input segment is parallel to one of the coordinate axes (i.e., iso-oriented). The algorithm for this problem runs in $O(\log n)$ time using an optimal $O(n + k / \log n)$ processors. The model of computation is the CREW PRAM model, where processor allocation must be explicit and global.

In-place techniques for parallel convex hull algorithms (preliminary version)

Abstract: We present a number of efficient parallel algorithms for constructing 2and 3-dimensional convex hulls on a randomized CRCW PRAM. Specifically, we show how to build the convex hull of n pre-sorted points in the plane almost surely in O(1) time using O(n log n) processors, or, alternately, almost surely in O(log” n) time using an optimal number of processors. We also show how to find the convex hull of n unsorted points in R2 (resp., 3?s) in O(log n) time using O(n log h) work (resp., 0(log2 n) time using O(min{n logz h, n log n}) work), with very high probability, where h is the number of edges in the convex hull (h is O(n), but can be as small as O(l)). Our algorithms for unsorted input depend on the use of new in-place procedures, that is, procedures that are defined on a subset of elements in the input and that work without re-ordering the input. For the pre-sorted case we also exploit a technique that allows one to modify an algorithm that assumes it is given points so that it can be used on hulls; we call such algorithms point-loll invariant. * This research supported in part by NSF and DARPA under Grant CCR-8908092. Email: ghouse@cs.jhu.edu. t ‘lhis rese~ch supported in part by the National Science FOUIIdation under Grant CCR-9003299, and by NSF and DARPA under Grant CCR-8908092. Email: goodrich@cs.jhu. edu. Permission to copy without fee all or part of this matertial is granted provided that the copies are not made or distributed for direct commercial advantage, the ACM copyright notice and the title of the publication and its date appear, and notice is given that copying is by permission of the Association for Computing Machinery. To copy otherwise, or to republish, requires a fee and/or specific permission.

Constructing arrangements optimally in parallel (preliminary version)

Abstract: of Results We give two optimal parallel algorithms for constructing the arrangement of n lines in the plane. The first method is quite simple and runs in O(log2 n) time using O(n2 ) work, and the second method, which is more sophisticated, runs in O(log n) time using O(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 ~-pseudo-nets, which may be of interest in its own right. Our results immediately imply that one can optimally construct the arrangement of n hyperplanes in 31d in O(log n) time using O(nd) work, for fixed d. Our algorithms are for the CREW PRAM.

A localized method for intersecting plane algebraic curve segments

Abstract: We present a local method for the computation of the intersections of plane algebraic curve segments. The conventional method of intersection is global, because it must first find all of the intersections between two curves before it can restrict the segments in question; hence, it cannot take advantage of situations dealing with the intersection of short-curve segments on complex curves. Our local method, on the other hand, will directly find only those intersections that lie on the segments, as it is based upon an extension of methods for tracing along a curve.