Searcharxiv⌕ Search

arXiv subjects

Mark de Berg

Publications and source records attributed to Mark de Berg.

At least 55 records · Page 3Linked to original sources
arXiv2018

Covering many points with a small-area box

Let $P$ be a set of $n$ points in the plane. We show how to find, for a given integer $k>0$, the smallest-area axis-parallel rectangle that covers $k$ points of $P$ in $O(nk^2 \log n+ n\log^2 n)$ time. We also consider the problem of, given a value $α>0$, covering as many points of $P$ as possible with an axis-parallel rectangle of area at most $α$. For this problem we give a probabilistic $(1-\varepsilon)$-approximation that works in near-linear time: In $O((n/\varepsilon^4)\log^3 n \log (1/\varepsilon))$ time we find an axis-parallel rectangle of area at most $α$ that, with high probability, covers at least $(1-\varepsilon)\mathrm{κ^*}$ points, where $\mathrm{κ^*}$ is the maximum possible number of points that could be covered.

cs.CG↗
arXiv2017

Shortcuts for the Circle

Let $C$ be the unit circle in $\mathbb{R}^2$. We can view $C$ as a plane graph whose vertices are all the points on $C$, and the distance between any two points on $C$ is the length of the smaller arc between them. We consider a graph augmentation problem on $C$, where we want to place $k\geq 1$ \emph{shortcuts} on $C$ such that the diameter of the resulting graph is minimized. We analyze for each $k$ with $1\leq k\leq 7$ what the optimal set of shortcuts is. Interestingly, the minimum diameter one can obtain is not a strictly decreasing function of~$k$. For example, with seven shortcuts one cannot obtain a smaller diameter than with six shortcuts. Finally, we prove that the optimal diameter is $2 + Θ(1/k^{\frac{2}{3}})$ for any~$k$.

math.MG↗
arXiv2017

Dynamic Conflict-Free Colorings in the Plane

We study dynamic conflict-free colorings in the plane, where the goal is to maintain a conflict-free coloring (CF-coloring for short) under insertions and deletions. - First we consider CF-colorings of a set $S$ of unit squares with respect to points. Our method maintains a CF-coloring that uses $O(\log n)$ colors at any time, where $n$ is the current number of squares in $S$, at the cost of only $O(\log n)$ recolorings per insertion or deletion of a square. We generalize the method to rectangles whose sides have lengths in the range $[1,c]$, where $c$ is a fixed constant. Here the number of used colors becomes $O(\log^2 n)$. The method also extends to arbitrary rectangles whose coordinates come from a fixed universe of size $N$, yielding $O(\log^2 N \log^2 n)$ colors. The number of recolorings for both methods stays in $O(\log n)$. - We then present a general framework to maintain a CF-coloring under insertions for sets of objects that admit a unimax coloring with a small number of colors in the static case. As an application we show how to maintain a CF-coloring with $O(\log^3 n)$ colors for disks (or other objects with linear union complexity) with respect to points at the cost of $O(\log n)$ recolorings per insertion. We extend the framework to the fully-dynamic case when the static unimax coloring admits weak deletions. As an application we show how to maintain a CF-coloring with $O(\sqrt{n} \log^2 n)$ colors for points with respect to rectangles, at the cost of $O(\log n)$ recolorings per insertion and $O(1)$ recolorings per deletion. These are the first results on fully-dynamic CF-colorings in the plane, and the first results for semi-dynamic CF-colorings for non-congruent objects.

cs.CG↗
arXiv2017

The Dominating Set Problem in Geometric Intersection Graphs

We study the parameterized complexity of dominating sets in geometric intersection graphs. In one dimension, we investigate intersection graphs induced by translates of a fixed pattern Q that consists of a finite number of intervals and a finite number of isolated points. We prove that Dominating Set on such intersection graphs is polynomially solvable whenever Q contains at least one interval, and whenever Q contains no intervals and for any two point pairs in Q the distance ratio is rational. The remaining case where Q contains no intervals but does contain an irrational distance ratio is shown to be NP-complete and contained in FPT (when parameterized by the solution size). In two and higher dimensions, we prove that Dominating Set is contained in W[1] for intersection graphs of semi-algebraic sets with constant description complexity. This generalizes known results from the literature. Finally, we establish W[1]-hardness for a large class of intersection graphs.

cs.CG↗
arXiv2017

Range-Clustering Queries

In a geometric $k$-clustering problem the goal is to partition a set of points in $\mathbb{R}^d$ into $k$ subsets such that a certain cost function of the clustering is minimized. We present data structures for orthogonal range-clustering queries on a point set $S$: given a query box $Q$ and an integer $k>2$, compute an optimal $k$-clustering for $S\setminus Q$. We obtain the following results. We present a general method to compute a $(1+ε)$-approximation to a range-clustering query, where $ε>0$ is a parameter that can be specified as part of the query. Our method applies to a large class of clustering problems, including $k$-center clustering in any $L_p$-metric and a variant of $k$-center clustering where the goal is to minimize the sum (instead of maximum) of the cluster sizes. We extend our method to deal with capacitated $k$-clustering problems, where each of the clusters should not contain more than a given number of points. For the special cases of rectilinear $k$-center clustering in $\mathbb{R}^1$, and in $\mathbb{R}^2$ for $k=2$ or 3, we present data structures that answer range-clustering queries exactly.

cs.CG↗
arXiv2017

The Homogeneous Broadcast Problem in Narrow and Wide Strips

Let $P$ be a set of nodes in a wireless network, where each node is modeled as a point in the plane, and let $s\in P$ be a given source node. Each node $p$ can transmit information to all other nodes within unit distance, provided $p$ is activated. The (homogeneous) broadcast problem is to activate a minimum number of nodes such that in the resulting directed communication graph, the source $s$ can reach any other node. We study the complexity of the regular and the hop-bounded version of the problem (in the latter, $s$ must be able to reach every node within a specified number of hops), with the restriction that all points lie inside a strip of width $w$. We almost completely characterize the complexity of both the regular and the hop-bounded versions as a function of the strip width $w$.

cs.CG↗
arXiv2017

Removing Depth-Order Cycles Among Triangles: An Efficient Algorithm Generating Triangular Fragments

More than 25 years ago Chazelle~\emph{et al.} (FOCS 1991) studied the following question: Is it possible to cut any set of $n$ lines in ${\Bbb R}^3$ into a subquadratic number of fragments such that the resulting fragments admit a depth order? They proved an $O(n^{9/4})$ bound for the very special case of bipartite weavings of lines. Since then only little progress was made, until a recent breakthrough by Aronov and Sharir (STOC 2016) who showed that $O(n^{3/2}\mathrm{polylog}\; n)$ fragments suffice for any set of lines. In a follow-up paper Aronov, Miller and Sharir (SODA 2017) proved an $O(n^{3/2+\varepsilon})$ bound for triangles, but their method results in pieces with curved boundaries. Moreover, their method uses polynomial partitions, for which currently no algorithm is known. Thus the most natural version of the problem is still wide open: Can we cut any collection of $n$ disjoint triangles in ${\Bbb R}^3$ into a subquadratic number of triangular fragments that admit a depth order? And if so, can we compute the cuts efficiently? We answer this question by presenting an algorithm that cuts any set of $n$ disjoint triangles in ${\Bbb R}^3$ into $O(n^{7/4}\mathrm{polylog}\; n)$ triangular fragments that admit a depth order. The running time of our algorithm is $O(n^{3.69})$. We also prove a refined bound that depends on the number, $K$, of intersections between the projections of the triangle edges onto the $xy$-plane: we show that $O(n^{1+\varepsilon} + n^{1/4} K^{3/4}\mathrm{polylog}\; n)$ fragments suffice to obtain a depth order. This result extends to $xy$-monotone surface patches bounded by a constant number of bounded-degree algebraic arcs, constituting the first subquadratic bound for surface patches. As a byproduct of our approach we obtain a faster algorithm to cut a set of lines into $O(n^{3/2}\mathrm{polylog}\; n)$ fragments that admit a depth order.

cs.CG↗
arXiv2017

Faster DB-scan and HDB-scan in Low-Dimensional Euclidean Spaces

We present a new algorithm for the widely used density-based clustering method DBscan. Our algorithm computes the DBscan-clustering in $O(n\log n)$ time in $\mathbb{R}^2$, irrespective of the scale parameter $\varepsilon$ (and assuming the second parameter MinPts is set to a fixed constant, as is the case in practice). Experiments show that the new algorithm is not only fast in theory, but that a slightly simplified version is competitive in practice and much less sensitive to the choice of $\varepsilon$ than the original DBscan algorithm. We also present an $O(n\log n)$ randomized algorithm for HDBscan in the plane---HDBscan is a hierarchical version of DBscan introduced recently---and we show how to compute an approximate version of HDBscan in near-linear time in any fixed dimension.

cs.CG↗
arXiv2016

Independent Set Reconfiguration Thresholds of Hereditary Graph Classes

Traditionally, reconfiguration problems ask the question whether a given solution of an optimization problem can be transformed to a target solution in a sequence of small steps that preserve feasibility of the intermediate solutions. In this paper, rather than asking this question from an algorithmic perspective, we analyze the combinatorial structure behind it. We consider the problem of reconfiguring one independent set into another, using two different processes: (1) exchanging exactly $k$ vertices in each step, or (2) removing or adding one vertex in each step while ensuring the intermediate sets contain at most $k$ fewer vertices than the initial solution. We are interested in determining the minimum value of $k$ for which this reconfiguration is possible, and bound these threshold values in terms of several structural graph parameters. For hereditary graph classes we identify structures that cause the reconfiguration threshold to be large.

cs.DM↗
arXiv2016

Fine-Grained Complexity Analysis of Two Classic TSP Variants

We analyze two classic variants of the Traveling Salesman Problem using the toolkit of fine-grained complexity. Our first set of results is motivated by the Bitonic TSP problem: given a set of $n$ points in the plane, compute a shortest tour consisting of two monotone chains. It is a classic dynamic-programming exercise to solve this problem in $O(n^2)$ time. While the near-quadratic dependency of similar dynamic programs for Longest Common Subsequence and Discrete Frechet Distance has recently been proven to be essentially optimal under the Strong Exponential Time Hypothesis, we show that bitonic tours can be found in subquadratic time. More precisely, we present an algorithm that solves bitonic TSP in $O(n \log^2 n)$ time and its bottleneck version in $O(n \log^3 n)$ time. Our second set of results concerns the popular $k$-OPT heuristic for TSP in the graph setting. More precisely, we study the $k$-OPT decision problem, which asks whether a given tour can be improved by a $k$-OPT move that replaces $k$ edges in the tour by $k$ new edges. A simple algorithm solves $k$-OPT in $O(n^k)$ time for fixed $k$. For 2-OPT, this is easily seen to be optimal. For $k=3$ we prove that an algorithm with a runtime of the form $\tilde{O}(n^{3-ε})$ exists if and only if All-Pairs Shortest Paths in weighted digraphs has such an algorithm. The results for $k=2,3$ may suggest that the actual time complexity of $k$-OPT is $Θ(n^k)$. We show that this is not the case, by presenting an algorithm that finds the best $k$-move in $O(n^{\lfloor 2k/3 \rfloor + 1})$ time for fixed $k \geq 3$. This implies that 4-OPT can be solved in $O(n^3)$ time, matching the best-known algorithm for 3-OPT. Finally, we show how to beat the quadratic barrier for $k=2$ in two important settings, namely for points in the plane and when we want to solve 2-OPT repeatedly.

cs.DS↗
arXiv2016

Distance-Sensitive Planar Point Location

Let $\mathcal{S}$ be a connected planar polygonal subdivision with $n$ edges that we want to preprocess for point-location queries, and where we are given the probability $γ_i$ that the query point lies in a polygon $P_i$ of $\mathcal{S}$. We show how to preprocess $\mathcal{S}$ such that the query time for a point~$p\in P_i$ depends on~$γ_i$ and, in addition, on the distance from $p$ to the boundary of~$P_i$---the further away from the boundary, the faster the query. More precisely, we show that a point-location query can be answered in time $O\left(\min \left(\log n, 1 + \log \frac{\mathrm{area}(P_i)}{γ_i Δ_{p}^2}\right)\right)$, where $Δ_{p}$ is the shortest Euclidean distance of the query point~$p$ to the boundary of $P_i$. Our structure uses $O(n)$ space and $O(n \log n)$ preprocessing time. It is based on a decomposition of the regions of $\mathcal{S}$ into convex quadrilaterals and triangles with the following property: for any point $p\in P_i$, the quadrilateral or triangle containing~$p$ has area $Ω(Δ_{p}^2)$. For the special case where $\mathcal{S}$ is a subdivision of the unit square and $γ_i=\mathrm{area}(P_i)$, we present a simpler solution that achieves a query time of $O\left(\min \left(\log n, \log \frac{1}{Δ_{p}^2}\right)\right)$. The latter solution can be extended to convex subdivisions in three dimensions.

cs.CG↗
arXiv2015

Finding Pairwise Intersections Inside a Query Range

We study the following problem: preprocess a set O of objects into a data structure that allows us to efficiently report all pairs of objects from O that intersect inside an axis-aligned query range Q. We present data structures of size $O(n({\rm polylog} n))$ and with query time $O((k+1)({\rm polylog} n))$ time, where k is the number of reported pairs, for two classes of objects in the plane: axis-aligned rectangles and objects with small union complexity. For the 3-dimensional case where the objects and the query range are axis-aligned boxes in R^3, we present a data structures of size $O(n\sqrt{n}({\rm polylog} n))$ and query time $O((\sqrt{n}+k)({\rm polylog} n))$. When the objects and query are fat, we obtain $O((k+1)({\rm polylog} n))$ query time using $O(n({\rm polylog} n))$ storage.

cs.DS↗
arXiv2015

Efficient Multi-Robot Motion Planning for Unlabeled Discs in Simple Polygons

We consider the following motion-planning problem: we are given $m$ unit discs in a simple polygon with $n$ vertices, each at their own start position, and we want to move the discs to a given set of $m$ target positions. Contrary to the standard (labeled) version of the problem, each disc is allowed to be moved to any target position, as long as in the end every target position is occupied. We show that this unlabeled version of the problem can be solved in $O(n\log n+mn+m^2)$ time, assuming that the start and target positions are at least some minimal distance from each other. This is in sharp contrast to the standard (labeled) and more general multi-robot motion-planning problem for discs moving in a simple polygon, which is known to be strongly NP-hard.

cs.CG↗
arXiv2013

Fat Polygonal Partitions with Applications to Visualization and Embeddings

Let $\mathcal{T}$ be a rooted and weighted tree, where the weight of any node is equal to the sum of the weights of its children. The popular Treemap algorithm visualizes such a tree as a hierarchical partition of a square into rectangles, where the area of the rectangle corresponding to any node in $\mathcal{T}$ is equal to the weight of that node. The aspect ratio of the rectangles in such a rectangular partition necessarily depends on the weights and can become arbitrarily high. We introduce a new hierarchical partition scheme, called a polygonal partition, which uses convex polygons rather than just rectangles. We present two methods for constructing polygonal partitions, both having guarantees on the worst-case aspect ratio of the constructed polygons; in particular, both methods guarantee a bound on the aspect ratio that is independent of the weights of the nodes. We also consider rectangular partitions with slack, where the areas of the rectangles may differ slightly from the weights of the corresponding nodes. We show that this makes it possible to obtain partitions with constant aspect ratio. This result generalizes to hyper-rectangular partitions in $\mathbb{R}^d$. We use these partitions with slack for embedding ultrametrics into $d$-dimensional Euclidean space: we give a $\mathop{\rm polylog}(Δ)$-approximation algorithm for embedding $n$-point ultrametrics into $\mathbb{R}^d$ with minimum distortion, where $Δ$ denotes the spread of the metric, i.e., the ratio between the largest and the smallest distance between two points. The previously best-known approximation ratio for this problem was polynomial in $n$. This is the first algorithm for embedding a non-trivial family of weighted-graph metrics into a space of constant dimension that achieves polylogarithmic approximation ratio.

cs.CG↗
arXiv2011

Treemaps with Bounded Aspect Ratio

Treemaps are a popular technique to visualize hierarchical data. The input is a weighted tree $\tree$ where the weight of each node is the sum of the weights of its children. A treemap for $\tree$ is a hierarchical partition of a rectangle into simply connected regions, usually rectangles. Each region represents a node of $\tree$ and its area is proportional to the weight of the corresponding node. An important quality criterion for treemaps is the aspect ratio of its regions. One cannot bound the aspect ratio if the regions are restricted to be rectangles. In contrast, \emph{polygonal partitions}, that use convex polygons, have bounded aspect ratio. We are the first to obtain convex partitions with optimal aspect ratio $O(\depth(\tree))$. However, $\depth(\tree)$ still depends on the input tree. Hence we introduce a new type of treemaps, namely \emph{orthoconvex treemaps}, where regions representing leaves are rectangles, L-, and S-shapes, and regions representing internal nodes are orthoconvex polygons. We prove that any input tree, irrespective of the weights of the nodes and the depth of the tree, admits an orthoconvex treemap of constant aspect ratio. We also obtain several specialized results for single-level treemaps, that is, treemaps where the input tree has depth~1.

cs.CG↗
arXiv2010

The Traveling Salesman Problem Under Squared Euclidean Distances

Let $P$ be a set of points in $\mathbb{R}^d$, and let $α\ge 1$ be a real number. We define the distance between two points $p,q\in P$ as $|pq|^α$, where $|pq|$ denotes the standard Euclidean distance between $p$ and $q$. We denote the traveling salesman problem under this distance function by TSP($d,α$). We design a 5-approximation algorithm for TSP(2,2) and generalize this result to obtain an approximation factor of $3^{α-1}+\sqrt{6}^α/3$ for $d=2$ and all $α\ge2$. We also study the variant Rev-TSP of the problem where the traveling salesman is allowed to revisit points. We present a polynomial-time approximation scheme for Rev-TSP$(2,α)$ with $α\ge2$, and we show that Rev-TSP$(d, α)$ is APX-hard if $d\ge3$ and $α>1$. The APX-hardness proof carries over to TSP$(d, α)$ for the same parameter ranges.

cs.CG↗