Showing papers by "Michael T. Goodrich published in 1988"
TL;DR: It is shown that a CREW-PRAM havingn1/k processors can compute the following functions in O(k1+ɛ) time: (i) the common tangents between P andQ, and (ii) the distance betweenP andQ (and hence a straight line separating them).
Abstract: Let P andQ be two convex,n-vertex polygons. We consider the problem of computing, in parallel, some functions ofP andQ whenP andQ are disjoint. The model of parallel computation we consider is the CREW-PRAM, i.e., it is the synchronous shared-memory model where concurrent reads are allowed but no two processors can simultaneously attempt to write in the same memory location (even if they are trying to write the same thing). We show that a CREW-PRAM havingn
1/k processors can compute the following functions in O(k1+ɛ) time: (i) the common tangents betweenP andQ, and (ii) the distance betweenP andQ (and hence a straight line separating them). The positive constant ɛ can be made arbitrarily close to zero. Even with a linear number of processors, it was not previously known how to achieve constant time performance for computing these functions. The algorithm for problem (ii) is easily modified to detect the case of zero distance as well.
70 citations
06 Jan 1988
TL;DR: These algorithms provide parallel analogues to well known phenomena from sequential computational geometry, such as the fact that problems for polygons can oftentimes be solved more efficiently that point-set problems, and that one can solve nearest-neighbor problems without explicitly constructing a Voronoi diagram.
Abstract: In this paper we give parallel algorithms for a number of problems defined on polygons and point sets. All of our algorithms have optimal T(n) *P(n) products, where T(n) is the time complexity and P(n) is the number of processors used, and are for the EREW PRAM or CREW PRAM models. In addition, our algorithms provide parallel analogues to well known phenomena from sequential computational geometry, such as the fact that problems for polygons can oftentimes be solved more efficiently that point-set problems, and that one can solve nearest-neighbor problems without explicitly constructing a Voronoi diagram.
56 citations
TL;DR: This work addresses the problems of finding the shortest path between two pointss andd inside P and compute the shortestpath tree between a single points and each vertex ofP, based on the divide-and-conquer paradigm.
Abstract: Given ann-vertex simple polygon we address the following problems: (i) find the shortest path between two pointss andd insideP, and (ii) compute the shortestpath tree between a single points and each vertex ofP (which implicitly represents all the shortest paths). We show how to solve the first problem inO(logn) time usingO(n) processors, and the more general second problem inO(log2n) time usingO(n) processors, and the more general second problem inO(log2n) time usingO(n) processors for any simple polygonP. We assume the CREW RAM shared memory model of computation in which concurrent reads are allowed, but no two processors should attempt to simultaneously write in the same memory location. The algorithms are based on the divide-and-conquer paradigm and are quite different from the known sequential algorithms
21 citations
01 Aug 1988
TL;DR: This work shows that the problem of evaluating S is in NC for various combinations of common set-manipulation operations, and develops techniques for improving the time and/or processor complexity.
Abstract: Given an off-line sequence S of n set-manipulation operations, we investigate the parallel complexity of evaluating S (i.e. finding the response to every operation in S and returning the resulting set). We show that the problem of evaluating S is in NC for various combinations of common set-manipulation operations. Once we establish membership in NC (or, if membershp in NC is obvious), we develop techniques for improving the time and/or processor complexity.
10 citations
01 Sep 1988
TL;DR: An algorithm for the well-known hidden-surface elimination problem for rectangles, which is also known as the window rendering problem, is presented and is asymptotically faster than previous ones.
Abstract: An algorithm for the well-known hidden-surface elimination problem for rectangles, which is also known as the window rendering problem is presented. The time complexity of the algorithm is sensitive to the size of the output. Specifically, it runs in time that is O (n(1.5) + k), where k is the size of the output (which can be as large as theta (n(squared)). For values of k in the range between n(1.5)/log n and n squared, the algorithm is asymptotically faster than previous ones.
6 citations
TL;DR: In this paper, a divide-and-conquer algorithm for finding the shortest path between two points and each vertex of a simple polygon is presented. But the algorithm requires O(log 2 n) time and O(n) processors.
Abstract: Given ann-vertex simple polygon we address the following problems: (i) find the shortest path between two pointss andd insideP, and (ii) compute the shortestpath tree between a single points and each vertex ofP (which implicitly represents all the shortest paths). We show how to solve the first problem inO(logn) time usingO(n) processors, and the more general second problem inO(log2n) time usingO(n) processors, and the more general second problem inO(log2n) time usingO(n) processors for any simple polygonP. We assume the CREW RAM shared memory model of computation in which concurrent reads are allowed, but no two processors should attempt to simultaneously write in the same memory location. The algorithms are based on the divide-and-conquer paradigm and are quite different from the known sequential algorithms
3 citations