Wolfgang Mulzer

Minimum-weight triangulation is NP-hard

A triangulation of a planar point set S is a maximal plane straight-line graph with vertex set S. In the minimum-weight triangulation (MWT) problem, we are looking for a triangulation of a given point set that minimizes the sum of the edge lengths. We prove that the decision version of this problem is NP-hard, using a reduction from PLANAR 1-IN-3-SAT. The correct working of the gadgets is established with computer assistance, using dynamic programming on polygonal faces, as well as the β-skeleton heuristic to certify that certain edges belong to the minimum-weight triangulation.

Constant-work-space algorithms for geometric problems

Constant-work-space algorithms may use only constantly many cells of storage in addition to their input, which is provided as a read-only array. We show how to construct several geometric structures eciently in the constant-work-space model. Traditional algo- rithms process the input into a suitable data structure (like a doubly-connected edge list) that allows ecient traversal of the structure at hand. In the constant-work-space setting, however, we cannot aord to do this. Instead, we provide operations that compute the desired features on the y by accessing the input with no extra space. The whole geomet- ric structure can be obtained by using these operations to enumerate all the features. Of course, we must pay for the space savings by slower running times. While the standard data structure allows us to implement traversal operations in constant time, our schemes typically take linear time to read the input data in each step. We begin with two simple problems: triangulating a planar point set and nding the trapezoidal decomposition of a simple polygon. In both cases adjacent features can be enumerated in linear time per step, resulting in total quadratic running time to output the whole structure. Actually, we show that the former result carries over to the Delaunay triangulation, and hence the Voronoi diagram. This also means that we can compute the largest empty circle of a planar point set in quadratic time and constant work-space. As another application, we demonstrate how to enumerate the features of an Euclidean minimum spanning tree (EMST) in quadratic time per step, so that the whole EMST can be found in cubic time using constant work-space.

Delaunay triangulations in O (sort( n )) time and more

We present several results about Delaunay triangulations (DTs) and convex hulls in transdichotomous and hereditary settings: (i) the DT of a planar point set can be computed in expected time O(sort(n)) on a word RAM, where sort(n)is the time to sort n numbers. We assume that the word RAM supports the shuffle-operation in constant time; (ii) if we know the ordering of a planar point set in x- and in y-direction, its DT can be found by a randomized algebraic computation tree of expected linear depth;(iii) given a universe U of points in the plane, we construct a data structure D for Delaunay queries: for any subset P of U, D can find the DT of P in time O(|P| loglog |U|); (iv) given a universe U of points in 3-space in general convex position, there is a data structure D for convex hull queries: for any subset P of U, D can find the convex hull of P in time O(|P| (log log |U|)^2);(v) given a convex polytope in 3-space with n vertices which are colored with k ≫ 2 colors, we can split it into the convex hulls of the individual color classes in time O(n (log log n)^2).The results (i)--(iii) generalize to higher dimensions. We need a wide range of techniques. Most prominently, we describe a reduction from DTs to nearest-neighbor graphs that relies on a new variant of randomized incremental constructions using dependent sampling.

Memory-constrained algorithms for simple polygons

A constant-work-space algorithm has read-only access to an input array and may use only O(1) additional words of O(log n) bits, where n is the input size. We show how to triangulate a plane straight-line graph with n vertices in O(n2) time and constant workspace. We also consider the problem of preprocessing a simple n-gon P for shortest path queries, where P is given by the ordered sequence of its vertices. For this, we relax the space constraint to allow s words of work-space. After quadratic preprocessing, the shortest path between any two points inside P can be found in O(n2/s) time.

Self-Improving Algorithms

We investigate ways in which an algorithm can improve its expected performance by fine-tuning itself automatically with respect to an arbitrary, unknown input distribution. We give such self-improving algorithms for sorting and clustering. The highlights of this work: (i) a sorting algorithm with optimal expected limiting running time; and (ii) a k-median algorithm over the Hamming cube with linear expected limiting running time. In all cases, the algorithm begins with a learning phase during which it adjusts itself to the input distribution (typically in a logarithmic number of rounds), followed by a stationary regime in which the algorithm settles to its optimized incarnation.

Preprocessing Imprecise Points for Delaunay Triangulation: Simplified and Extended

Suppose we want to compute the Delaunay triangulation of a set P whose points are restricted to a collection ℛ of input regions known in advance. Building on recent work by Löffler and Snoeyink, we show how to leverage our knowledge of ℛ for faster Delaunay computation. Our approach needs no fancy machinery and optimally handles a wide variety of inputs, e.g., overlapping disks of different sizes and fat regions.

Computing hereditary convex structures

Color red and blue the n vertices of a convex polytope P in R3. Can we compute the convex hull of each color class in o(n log n)? What if we have k > 2 colors? What if the colors are random? Consider an arbitrary query halfspace and call the vertices of P inside it blue: can the convex hull of the blue points be computed in time linear in their number? More generally, can we quickly compute the blue hull without looking at the whole polytope? This paper considers several instances of hereditary computation and provides new results for them. In particular, we resolve an eight-year old open problem by showing how to split a convex polytope in linear expected time.

Reprint of: Memory-constrained algorithms for simple polygons

A constant-work-space algorithm has read-only access to an input array and may use only O(1) additional words of O(logn) bits, where n is the input size. We show how to triangulate a plane straight-line graph with n vertices in O(n^2) time and constant work-space. We also consider the problem of preprocessing a simple polygon P for shortest path queries, where P is given by the ordered sequence of its n vertices. For this, we relax the space constraint to allow s words of work-space. After quadratic preprocessing, the shortest path between any two points inside P can be found in O(n^2/s) time.

Dynamic planar voronoi diagrams for general distance functions and their algorithmic applications

We describe a new data structure for dynamic nearest neighbor queries in the plane with respect to a general family of distance functions that includes

Computing the Fréchet Distance with a Retractable Leash

L_p