Improving the dilation of a metric graph by adding edges

Most of the literature on spanners focuses on building the graph from scratch. This paper instead focuses on adding edges to improve an existing graph. A major open problem in this field is: given a graph embedded in a metric space, and a budget of k edges, which k edges do we add to produce a minimum-dilation graph? The special case where k=1 has been studied in the past, but no major breakthroughs have been made for k > 1. We provide the first positive result, an O(k)-approximation algorithm that runs in O(n^3 \log n) time

Computing the Yolk in Spatial Voting Games without Computing Median Lines

The yolk is an important concept in spatial voting games as it generalises the equilibrium and provides bounds on the uncovered set. We present near-linear time algorithms for computing the yolk in the spatial voting model in the plane. To the best of our knowledge our algorithm is the first algorithm that does not require precomputing the median lines and hence able to break the existing $O(n^{4/3})$ bound which equals the known upper bound on the number of median lines. We avoid this requirement by using Megiddo's parametric search, which is a powerful framework that could lead to faster algorithms for many other spatial voting problems

Approximating the Packedness of Polygonal Curves

In 2012 Driemel et al. \cite{DBLP:journals/dcg/DriemelHW12} introduced the concept of $c$-packed curves as a realistic input model. In the case when $c$ is a constant they gave a near linear time $(1+\varepsilon)$-approximation algorithm for computing the Fr\'echet distance between two $c$-packed polygonal curves. Since then a number of papers have used the model. In this paper we consider the problem of computing the smallest $c$ for which a given polygonal curve in $\mathbb{R}^d$ is $c$-packed. We present two approximation algorithms. The first algorithm is a $2$-approximation algorithm and runs in $O(dn^2 \log n)$ time. In the case $d=2$ we develop a faster algorithm that returns a $(6+\varepsilon)$-approximation and runs in $O((n/\varepsilon^3)^{4/3} polylog (n/\varepsilon)))$ time. We also implemented the first algorithm and computed the approximate packedness-value for 16 sets of real-world trajectories. The experiments indicate that the notion of $c$-packedness is a useful realistic input model for many curves and trajectories.Comment: A preliminary version to appear in ISAAC 202

Analysing trajectory similarity and improving graph dilation

In this thesis, we focus on two topics in computational geometry. The first topic is analysing trajectory similarity. A trajectory tracks the movement of an object over time. A common way to analyse trajectories is by finding similarities. The Fr\'echet distance is a similarity measure that has gained popularity in the theory community, since it takes the continuity of the curves into account. One way to analyse trajectories using the Fr\'echet distance is to cluster trajectories into groups of similar trajectories. For vehicle trajectories, another way to analyse trajectories is to compute the path on the underlying road network that best represents the trajectory. The second topic is improving graph dilation. Dilation measures the quality of a network in applications such as transportation and communication networks. Spanners are low dilation graphs with not too many edges. Most of the literature on spanners focuses on building the graph from scratch. We instead focus on adding edges to improve the dilation of an existing graph

Map matching queries on realistic input graphs under the Fr\'echet distance

Map matching is a common preprocessing step for analysing vehicle trajectories. In the theory community, the most popular approach for map matching is to compute a path on the road network that is the most spatially similar to the trajectory, where spatial similarity is measured using the Fr\'echet distance. A shortcoming of existing map matching algorithms under the Fr\'echet distance is that every time a trajectory is matched, the entire road network needs to be reprocessed from scratch. An open problem is whether one can preprocess the road network into a data structure, so that map matching queries can be answered in sublinear time. In this paper, we investigate map matching queries under the Fr\'echet distance. We provide a negative result for geometric planar graphs. We show that, unless SETH fails, there is no data structure that can be constructed in polynomial time that answers map matching queries in $O((pq)^{1-\delta})$ query time for any $\delta > 0$, where $p$ and $q$ are the complexities of the geometric planar graph and the query trajectory, respectively. We provide a positive result for realistic input graphs, which we regard as the main result of this paper. We show that for $c$-packed graphs, one can construct a data structure of $\tilde O(cp)$ size that can answer $(1+\varepsilon)$-approximate map matching queries in $\tilde O(c^4 q \log^4 p)$ time, where $\tilde O(\cdot)$ hides lower-order factors and dependence of $\varepsilon$.Comment: To appear in SODA 202

Computing a Subtrajectory Cluster from c-packed Trajectories

We present a near-linear time approximation algorithm for the subtrajectory cluster problem of $c$-packed trajectories. The problem involves finding $m$ subtrajectories within a given trajectory $T$ such that their Fr\'echet distances are at most $(1 + \varepsilon)d$, and at least one subtrajectory must be of length~$l$ or longer. A trajectory $T$ is $c$-packed if the intersection of $T$ and any ball $B$ with radius $r$ is at most $c \cdot r$ in length. Previous results by Gudmundsson and Wong \cite{GudmundssonWong2022Cubicupperlower} established an $\Omega(n^3)$ lower bound unless the Strong Exponential Time Hypothesis fails, and they presented an $O(n^3 \log^2 n)$ time algorithm. We circumvent this conditional lower bound by studying subtrajectory cluster on $c$-packed trajectories, resulting in an algorithm with an $O((c^2 n/\varepsilon^2)\log(c/\varepsilon)\log(n/\varepsilon))$ time complexity

The Tight Spanning Ratio of the Rectangle Delaunay Triangulation

Spanner construction is a well-studied problem and Delaunay triangulations are among the most popular spanners. Tight bounds are known if the Delaunay triangulation is constructed using an equilateral triangle, a square, or a regular hexagon. However, all other shapes have remained elusive. In this paper we extend the restricted class of spanners for which tight bounds are known. We prove that Delaunay triangulations constructed using rectangles with aspect ratio \A have spanning ratio at most \sqrt{2} \sqrt{1+\A^2 + \A \sqrt{\A^2 + 1}}, which matches the known lower bound

Oriented Spanners

Given a point set P in the Euclidean plane and a parameter t, we define an oriented t-spanner as an oriented subgraph of the complete bi-directed graph such that for every pair of points, the shortest cycle in G through those points is at most a factor t longer than the shortest oriented cycle in the complete bi-directed graph. We investigate the problem of computing sparse graphs with small oriented dilation. As we can show that minimising oriented dilation for a given number of edges is NP-hard in the plane, we first consider one-dimensional point sets. While obtaining a 1-spanner in this setting is straightforward, already for five points such a spanner has no plane embedding with the leftmost and rightmost point on the outer face. This leads to restricting to oriented graphs with a one-page book embedding on the one-dimensional point set. For this case we present a dynamic program to compute the graph of minimum oriented dilation that runs in ?(n?) time for n points, and a greedy algorithm that computes a 5-spanner in ?(nlog n) time. Expanding these results finally gives us a result for two-dimensional point sets: we prove that for convex point sets the greedy triangulation results in an oriented ?(1)-spanner