Showing papers by "Herbert Edelsbrunner published in 1991"

Euclidean minimum spanning trees and bichromatic closest pairs

Abstract: We present an algorithm to compute a Euclidean minimum spanning tree of a given setS ofN points inEd in timeO(Fd(N,N) logdN), whereFd(n,m) is the time required to compute a bichromatic closest pair amongn red andm green points inEd. IfFd(N,N)=Ω(N1+?), for some fixed ?>0, then the running time improves toO(Fd(N,N)). Furthermore, we describe a randomized algorithm to compute a bichromatic closest pair in expected timeO((nm logn logm)2/3+m log2n+n log2m) inE3, which yields anO(N4/3 log4/3N) expected time, algorithm for computing a Euclidean minimum spanning tree ofN points inE3. Ind?4 dimensions we obtain expected timeO((nm)1?1/([d/2]+1)+?+m logn+n logm) for the bichromatic closest pair problem andO(N2?2/([d/2]+1)?) for the Euclidean minimum spanning tree problem, for any positive ?.

On the Zone Theorem for Hyperplane Arrangements

Abstract: The zone theorem for an arrangement of n hyperplanes in d-dimensional real space says that the total number of faces bounding the cells intersected by another hyperplane is O(nd−1). This result is the basis of a time-optimal incremental algorithm that constructs a hyperplane arrangement and has a host of other algorithmic and combinatorial applications. Unfortunately, the original proof of the zone theorem, for d ≥ 3, turned out to contain a serious and irreparable error. This paper presents a new proof of the theorem. Our proof is based on an inductive argument, which also applies in the case of pseudo-hyperplane arrangements. We also briefly discuss the fallacies of the old proof along with some ways of partially saving that approach.

Computing a face in an arrangement of line segments

Abstract: This paper presents a randomized incremental algorithm for computing a single face in an arrangement of n line segments in the plane that is fairly simple to implement. The expected running time of the algorithm is $O(n\alpha (n)\log n)$. The analysis of the algorithm uses a novel approach that generalizes and extends the Clarkson–Shor analysis technique [in Discrete Comput. Geom., 4 (1989), pp. 387–421]. A few extensions of the technique, obtaining efficient randomized incremental algorithms for constructing the entire arrangement of a collection of line segments and for computing a single face in an arrangement of Jordan arcs are also presented.

Points and triangles in the plane and halving planes in space

Abstract: We prove that for any setS ofn points in the plane andn3?? triangles spanned by the points inS there exists a point (not necessarily inS) contained in at leastn3?3?/(c log5n) of the triangles. This implies that any set ofn points in three-dimensional space defines at most $$\sqrt[3]{{(c/2)}}n^{8/3} \log ^{5/3} n$$ halving planes.

Ray Shooting in Polygons Using Geodesic Triangulations

Abstract: Let P be a simple polygon with n vertices. We present a simple decomposition scheme that partitions the interior of P into O(n) so-called geodesic triangles, so that any line segment interior to P crosses at most 2 log n of these triangles. This decomposition can be used to preprocess P in time O(n log n) and storage O(n), so that any ray-shooting query can be answered in time O(log n).The algorithms are fairly simple and easy to implement. We also extend this technique to the case of ray-shooting amidst k polygonal obstacles with a total of n edges, so that a query can be answered in O(√klog n) time.

An O( n log 2 h ) time algorithm for the three-dimensional convex hull problem

Abstract: An algorithm is presented that constructs the convex hull of a set of n points in three dimensions in worst-case time $O(n\log ^2 h)$and storage $O(n)$, where h is the number of extreme points. This is an improvement of the $O(nh)$ time gift-wrapping algorithm and, if $h = o(2^{\sqrt {\log _2 n} } )$, of the $O(n\log n)$ time divide-and-conquer algorithm.

Counting and cutting cycles of lines and rods in space

Abstract: A number of rendering algorithms in computer graphics sort three-dimensional objects by depth and assume that there is no cycle that makes the sorting impossible. One way to resolve the problem caused by cycles is to cut the objects into smaller pieces. The problem of estimating how many such cuts are always sufficient is addressed. A few related algorithmic and combinatorial geometry problems are considered. >