45 Hits in 2.5 sec

Preprocessing Ambiguous Imprecise Points [article]

Ivor van der Hoog, Irina Kostitsyna, Maarten Löffler, Bettina Speckmann
2019 arXiv   pre-print
I. van der Hoog, I. Kostitsyna, M. Löffler, A set of intervals with a containment graph with quadratic complexity. Height and Depth partition.  ...  Figure 13 .Figure 13 1313 I. van der Hoog, I. Kostitsyna, M. Löffler, We may need to allow parents of leaves of T to have a single dummy leaf.  ... 
arXiv:1903.08280v1 fatcat:mxw5uqbcyrf6jkfwdguj4ymigq

Adaptive Out-Orientations with Applications [article]

Aleksander B. G. Christiansen, Jacob Holm, Ivor van der Hoog, Eva Rotenberg, Chris Schwiegelshohn
2022 arXiv   pre-print
We give simple algorithms for maintaining edge-orientations of a fully-dynamic graph, such that the out-degree of each vertex is bounded. On one hand, we show how to orient the edges such that the out-degree of each vertex is proportional to the arboricity α of the graph, in a worst-case update time of O(log^2 n logα). On the other hand, motivated by applications in dynamic maximal matching, we obtain a different trade-off, namely the improved worst case update time of O(log n logα) for the
more » ... lem of maintaining an edge-orientation with at most O(α + log n) out-edges per vertex. Since our algorithms have update times with worst-case guarantees, the number of changes to the solution (i.e. the recourse) is naturally limited. Our algorithms make choices based entirely on local information, which makes them automatically adaptive to the current arboricity of the graph. In other words, they are arboricity-oblivious, while they are arboricity-sensitive. This both simplifies and improves upon previous work, by having fewer assumptions or better asymptotic guarantees. As a consequence, one obtains an algorithm with improved efficiency for maintaining a (1+ε) approximation of the maximum subgraph density, and an algorithm for dynamic maximal matching whose worst-case update time is guaranteed to be upper bounded by O(α + log nlogα), where α is the arboricity at the time of the update.
arXiv:2209.14087v1 fatcat:3q5s6r72avg6jkih3mdyhrvm6i

Preprocessing Imprecise Points for the Pareto Front [article]

Ivor van der Hoog, Irina Kostitsyna, Maarten Löffler, Bettina Speckmann
2021 arXiv   pre-print
Van der Hoog et al.  ...  Erickson, van der Hoog and Miltzow define the real RAM in two steps.  ... 
arXiv:2101.06079v1 fatcat:5ll4ebpierfmbcxmha4mjiggiu

Dynamic Embeddings of Dynamic Single-Source Upward Planar Graphs [article]

Ivor van der Hoog, Irene Parada, Eva Rotenberg
2022 arXiv   pre-print
A directed graph G is upward planar if it admits a planar embedding such that each edge is y-monotone. Unlike planarity testing, upward planarity testing is NP-hard except in restricted cases, such as when the graph has the single-source property (i.e. each connected component only has one source). In this paper, we present a dynamic algorithm for maintaining a combinatorial embedding ℰ(G) of a single-source upward planar graph subject to edge deletions, edge contractions, edge insertions
more » ... s across a face, and single-source-preserving vertex splits through specified corners. We furthermore support changes to the embedding ℰ(G) on the form of subgraph flips that mirror or slide the placement of a subgraph that is connected to the rest of the graph via at most two vertices. All update operations are supported as long as the graph remains upward planar, and all queries are supported as long as the graph remains single-source. Updates that violate upward planarity are identified as such and rejected by our update algorithm. We dynamically maintain a linear-size data structure on G which supports incidence queries between a vertex and a face, and upward-linkability of vertex pairs. If a pair of vertices are not upwards-linkable, we facilitate one-flip-linkable queries that point to a subgraph flip that makes them linkable, if any such flip exists. We support all updates and queries in O(log^2 n) time.
arXiv:2209.14094v1 fatcat:sjrfviae7zf3laloljpnunm3ue

Worst-case Deterministic Fully-Dynamic Planar 2-vertex Connectivity [article]

Jacob Holm, Ivor van der Hoog, Eva Rotenberg
2022 arXiv   pre-print
We study dynamic planar graphs with n vertices, subject to edge deletion, edge contraction, edge insertion across a face, and the splitting of a vertex in specified corners. We dynamically maintain a combinatorial embedding of such a planar graph, subject to connectivity and 2-vertex-connectivity (biconnectivity) queries between pairs of vertices. Whenever a query pair is connected and not biconnected, we find the first and last cutvertex separating them. Additionally, we allow local changes to
more » ... the embedding by flipping the embedding of a subgraph that is connected by at most two vertices to the rest of the graph. We support all queries and updates in deterministic, worst-case, O(log^2 n) time, using an O(n)-sized data structure. Previously, the best bound for fully-dynamic planar biconnectivity (subject to our set of operations) was an amortised Õ(log^3 n) for general graphs, and algorithms with worst-case polylogarithmic update times were known only in the partially dynamic (insertion-only or deletion-only) setting.
arXiv:2209.14079v1 fatcat:odcw4djniralrhm2vm2yixdxs4

Efficient Fréchet distance queries for segments [article]

Maike Buchin, Ivor van der Hoog, Tim Ophelders, Lena Schlipf, Rodrigo I. Silveira, Frank Staals
2022 arXiv   pre-print
[36] , a polynomial-time algorithm for computing an optimal local simplification for the Fréchet distance by van Kreveld et al.  ... 
arXiv:2203.01794v1 fatcat:z55jppanpbh3hfd3k7haji7fki

Topological Stability of Kinetic k-Centers [article]

Ivor van der Hoog, Marc van Kreveld, Wouter Meulemans, Kevin Verbeek, Jules Wulms
2021 arXiv   pre-print
We study the k-center problem in a kinetic setting: given a set of continuously moving points P in the plane, determine a set of k (moving) disks that cover P at every time step, such that the disks are as small as possible at any point in time. Whereas the optimal solution over time may exhibit discontinuous changes, many practical applications require the solution to be stable: the disks must move smoothly over time. Existing results on this problem require the disks to move with a bounded
more » ... ed, but this model allows positive results only for k<3. Hence, the results are limited and offer little theoretical insight. Instead, we study the topological stability of k-centers. Topological stability was recently introduced and simply requires the solution to change continuously, but may do so arbitrarily fast. We prove upper and lower bounds on the ratio between the radii of an optimal but unstable solution and the radii of a topologically stable solution – the topological stability ratio – considering various metrics and various optimization criteria. For k = 2 we provide tight bounds, and for small k > 2 we can obtain nontrivial lower and upper bounds. Finally, we provide an algorithm to compute the topological stability ratio in polynomial time for constant k.
arXiv:1810.00794v2 fatcat:unje3yxxwjhopgowka6qcnpwkq

Trajectory Visibility

Patrick Eades, Ivor van der Hoog, Maarten Löffler, Frank Staals, Susanne Albers
2020 Scandinavian Workshop on Algorithm Theory  
Eades, I. van der Hoog, M. Löffler, and F. Staals Figure 9 (left) A simple polygon split in O(n 2 ) cells. For each cell, there exists a red-black tree that represents a visibility polygon.  ... 
doi:10.4230/lipics.swat.2020.23 dblp:conf/swat/EadesHLS20 fatcat:4r64i4izn5gpndfrfztipbbsxi

Preprocessing Ambiguous Imprecise Points

Ivor Van Der Hoog, Irina Kostitsyna, Maarten Löffler, Bettina Speckmann, Michael Wagner
2019 International Symposium on Computational Geometry  
I. van der Hoog, I. Kostitsyna, M. Löffler, and B.  ...  Hoog et al.  ... 
doi:10.4230/lipics.socg.2019.42 dblp:conf/compgeom/HoogKLS19 fatcat:wgcoyvfydncrvhykoufl6baie4

Smoothing the gap between NP and ER [article]

Jeff Erickson, Ivor van der Hoog, Tillmann Miltzow
2021 arXiv   pre-print
We study algorithmic problems that belong to the complexity class of the existential theory of the reals (ER). A problem is ER-complete if it is as hard as the problem ETR and if it can be written as an ETR formula. Traditionally, these problems are studied in the real RAM, a model of computation that assumes that the storage and comparison of real-valued numbers can be done in constant space and time, with infinite precision. The complexity class ER is often called a real RAM analogue of NP,
more » ... nce the problem ETR can be viewed as the real-valued variant of SAT. In this paper we prove a real RAM analogue to the Cook-Levin theorem which shows that ER membership is equivalent to having a verification algorithm that runs in polynomial-time on a real RAM. This gives an easy proof of ER-membership, as verification algorithms on a real RAM are much more versatile than ETR-formulas. We use this result to construct a framework to study ER-complete problems under smoothed analysis. We show that for a wide class of ER-complete problems, its witness can be represented with logarithmic input-precision by using smoothed analysis on its real RAM verification algorithm. This shows in a formal way that the boundary between NP and ER (formed by inputs whose solution witness needs high input-precision) consists of contrived input. We apply our framework to well-studied ER-complete recognition problems which have the exponential bit phenomenon such as the recognition of realizable order types or the Steinitz problem in fixed dimension.
arXiv:1912.02278v3 fatcat:kdjz7pabgrhqdgdvhd4g5jprhu

Maximum-Area Triangle in a Convex Polygon, Revisited [article]

Vahideh Keikha and Maarten Löffler and Ali Mohades and Jérôme Urhausen and Ivor van der Hoog
2017 arXiv   pre-print
We revisit the following problem: Given a convex polygon P, find the largest-area inscribed triangle. We show by example that the linear-time algorithm presented in 1979 by Dobkin and Snyder for solving this problem fails. We then proceed to show that with a small adaptation, their approach does lead to a quadratic-time algorithm. We also present a more involved O(n n) time divide-and-conquer algorithm. Also we show by example that the algorithm presented in 1979 by Dobkin and Snyder for
more » ... the largest-area k-gon that is inscribed in a convex polygon fails to find the optimal solution for k=4. Finally, we discuss the implications of our discoveries on the literature.
arXiv:1705.11035v2 fatcat:2axjswqvujbhbhricckfxhtq6i

Maximum-Area Quadrilateral in a Convex Polygon, Revisited [article]

Vahideh Keikha, Maarten Löffler, Ali Mohades, Jérôme Urhausen, Ivor van der Hoog
2017 arXiv   pre-print
In this note we show by example that the algorithm presented in 1979 by Dobkin and Snyder for finding the largest-area k-gon that is inscribed in a convex polygon fails to find the optimal solution for k=4. This question, posed by Keikha et al. where they showed that the Dobkin Snyder algorithm fails for k=3.
arXiv:1708.00681v3 fatcat:juxboyefdvcozm7hblqsetlq5a

Segment Visibility Counting Queries in Polygons [article]

Kevin Buchin, Bram Custers, Ivor van der Hoog, Maarten Löffler, Aleksandr Popov, Marcel Roeloffzen, Frank Staals
Let $P$ be a simple polygon with $n$ vertices, and let $A$ be a set of $m$ points or line segments inside $P$. We develop data structures that can efficiently count the number of objects from $A$ that are visible to a query point or a query segment. Our main aim is to obtain fast, $O(\mathop{\textrm{polylog}} nm$), query times, while using as little space as possible. In case the query is a single point, a simple visibility-polygon-based solution achieves $O(\log nm)$ query time using $O(nm^2)$
more » ... space. In case $A$ also contains only points, we present a smaller, $O(n + m^{2 + \varepsilon}\log n)$-space, data structure based on a hierarchical decomposition of the polygon. Building on these results, we tackle the case where the query is a line segment and $A$ contains only points. The main complication here is that the segment may intersect multiple regions of the polygon decomposition, and that a point may see multiple such pieces. Despite these issues, we show how to achieve $O(\log n\log nm)$ query time using only $O(nm^{2 + \varepsilon} + n^2)$ space. Finally, we show that we can even handle the case where the objects in $A$ are segments with the same bounds.
doi:10.48550/arxiv.2201.03490 fatcat:ahmievtz7nbhloeieaxlm5ubj4

On the Discrete Fréchet Distance in a Graph

Anne Driemel, Ivor van der Hoog, Eva Rotenberg, Xavier Goaoc, Michael Kerber
Driemel, I. van der Hoog, and E. Rotenberg 36:5 Distance oracles.  ...  Driemel, I. van der Hoog, and E. Rotenberg 36:15 We show that if there exist two orthogonal vectors (a, b) ∈ A × B then D F (P, Q) < 3.  ...  Driemel, I. van der Hoog, and E. Rotenberg 36:13 The gadgets for vectors in B and in A. The path corresponding to B will traverse blue vertices, the path corresponding to A red.  ... 
doi:10.4230/lipics.socg.2022.36 fatcat:peydwmxmljbrhplmjhr3csjcdi

Efficient Fréchet Distance Queries for Segments

Maike Buchin, Ivor van der Hoog, Tim Ophelders, Lena Schlipf, Rodrigo I. Silveira, Frank Staals, Shiri Chechik, Gonzalo Navarro, Eva Rotenberg, Grzegorz Herman
We study the problem of constructing a data structure that can store a two-dimensional polygonal curve P, such that for any query segment ab one can efficiently compute the Fréchet distance between P and ab. First we present a data structure of size O(n log n) that can compute the Fréchet distance between P and a horizontal query segment ab in O(log n) time, where n is the number of vertices of P. In comparison to prior work, this significantly reduces the required space. We extend the type of
more » ... ueries allowed, as we allow a query to be a horizontal segment ab together with two points s, t ∈ P (not necessarily vertices), and ask for the Fréchet distance between ab and the curve of P in between s and t. Using O(nlog²n) storage, such queries take O(log³ n) time, simplifying and significantly improving previous results. We then generalize our results to query segments of arbitrary orientation. We present an O(nk^{3+ε}+n²) size data structure, where k ∈ [1,n] is a parameter the user can choose, and ε > 0 is an arbitrarily small constant, such that given any segment ab and two points s, t ∈ P we can compute the Fréchet distance between ab and the curve of P in between s and t in O((n/k)log²n+log⁴ n) time. This is the first result that allows efficient exact Fréchet distance queries for arbitrarily oriented segments. We also present two applications of our data structure. First, we show that our data structure allows us to compute a local δ-simplification (with respect to the Fréchet distance) of a polygonal curve in O(n^{5/2+ε}) time, improving a previous O(n³) time algorithm. Second, we show that we can efficiently find a translation of an arbitrary query segment ab that minimizes the Fréchet distance with respect to a subcurve of P.
doi:10.4230/lipics.esa.2022.29 fatcat:sfgr375inbdtnogvulmpwxakh4
« Previous Showing results 1 — 15 out of 45 results