Homotopic rectilinear routing with few links and thick edges

We study the problem of finding non-crossing thick minimum-link rectilinear paths homotopic to a set of input paths in an environment with rectangular obstacles. This problem occurs in the context of map schematization under geometric embedding restrictions, for example, when schematizing a highway network for use as a thematic layer. We present a 2-approximation algorithm that runs in O(n3 +kin log n + kout) time, where n is the total number of input paths and obstacles and kin and kout are the total complexities of the input and output paths, respectively. Our algorithm not only approximates the minimum number of links, but also minimizes the total length of the paths. An approximation factor of 2 is optimal when using smallest paths as lower bound

Algorithms for necklace maps

Necklace maps visualize quantitative data associated with regions by placing scaled symbols, usually disks, without overlap on a closed curve (the necklace) surrounding the map regions. Each region is projected onto an interval on the necklace that contains its symbol. In this paper we address the algorithmic question how to maximize symbol sizes while keeping symbols disjoint and inside their intervals. For that we reduce the problem to a one-dimensional problem which we solve efficiently. Solutions to the one-dimensional problem provide a very good approximation for the original necklace map problem. We consider two variants: Fixed-Order, where an order for the symbols on the necklace is given, and Any-Order where any symbol order is possible. The Fixed-Order problem can be solved in O(n log n) time. We show that the Any-Order problem is NP-hard for certain types of intervals and give an exact algorithm for the decision version. This algorithm is fixed-parameter tractable in the thickness K of the input. Our algorithm runs in O(n log n + n2K4K) time which can be improved to O(n log n + nK2K) time using a heuristic. We implemented our algorithm and evaluated it experimentally. Keywords: Necklace maps; scheduling; automated cartograph

Guest Editor's Foreword (Special Issue with Selected Papers from the 19th International Symposium on Graph Drawing, GD 2011)

This issue of the Journal of Graph Algorithms and Applications is devoted to the nineteenth International Symposium on Graph Drawing, held September 19-21, 2011, in Eindhoven, the Netherlands

Computing the Fréchet distance with shortcuts is NP-hard

We study the shortcut Fréchet distance, a natural variant of the Fréchet distance that allows us to take shortcuts from and to any point along one of the curves. We show that, surprisingly, the problem of computing the shortcut Fréchet distance exactly is NP-hard. Furthermore, we give a 3-approximation algorithm for the decision version of the problem

Area-preserving C-oriented schematization

We define an edge-move operation for polygons and prove that every simple non-convex polygon P has a non-conflicting pair of complementary edge-moves that reduces the number of edges of P while preserving its area. We use this result to generate area-preserving C-oriented schematizations of polygons

On the number of regular edge labelings

We prove that any irreducible triangulation on n vertices has O (4:6807n ) regular edge labeling,s and that there are irreducible triangulations on n vertices with (3:0426n ) regular edge labelings. Our upper bound relies on a novel application of Shearer's entropy lemma. As an example of the wider applicability of this technique, we also improve the upper bound on the number of 2-orientations of a quadrangulation to O (1:87n ). Keywords: Counting; Regular edge labeling; Shearer's entropy lemm

Kinetic collision detection for low-density scenes in the black-box model

We present an efficient method for collision detection in the black-box KDS model for a set S of n objects in the plane. In this model we receive the object locations at regular time steps and we know a bound dmax on the maximum displacement of any object within one time step. Our method maintains, in O((¿+k)n) time per time step, a compressed quadtree on the bounding-box vertices of the objects; here ¿ denotes the density of S and k denotes the maximum number of objects that can intersect any disk of radius dmax. Collisions can then be detected by testing O((¿+k)2n) pairs of objects for intersection

Kinetic kd-trees

We propose a simple variant of kd-trees, called rankbased kd-trees, for sets of points in Rd. We show that a rank-based kd-tree, like an ordinary kd-tree, supports range search queries in O(n1-1/d + k) time, where k is the output size. The main advantage of rank-based kd-trees is that they can be efficiently kinetized: the KDS processes O(n2) events in the worst case, assuming that the points follow constantdegree algebraic trajectories, each event can be handled in O(log n) time, and each point is involved in O(1) certificates

Kinetic Euclidean 2-centers in the black-box model

We study the 2-center problem for moving points in the plane. Given a set P of n points, the Euclidean 2-center problem asks for two congruent disks of minimum size that together cover P. Our methods work in the black-box KDS model, where we receive the locations of the points at regular time steps and we know an upper bound d_max on the maximum displacement of any point within one time step. We show how to maintain a (1 + e)-approximation of the Euclidean 2-center in amortized sub-linear time per time step, under certain assumptions on the distribution of the point set P. In many cases --namely when the distance between the centers of the disks is relatively large or relatively small-- the solution we maintain is actually optimal

A framework for algorithm stability

We say that an algorithm is stable if small changes in the input result in small changes in the output. Algorithm stability plays an important role when analyzing and visualizing time-varying data. However, so far, there are only few theoretical results on the stability of algorithms, possibly due to a lack of theoretical analysis tools. In this paper we present a framework for analyzing the stability of algorithms. We focus in particular on the tradeoff between the stability of an algorithm and the quality of the solution it computes. Our framework allows for three types of stability analysis with increasing degrees of complexity: event stability, topological stability, and Lipschitz stability. We demonstrate the use of our stability framework by applying it to kinetic Euclidean minimum spanning trees