Consider a stream of n random points (say, from the unit square) arriving one by one, where a player must make an immediate and irreversible decision upon each point’s arrival, whether to pick it. The player must pick exactly one such point, and the payoff is the area of the cell of the picked point, in the final Voronoi diagram of all the points. We show that there is a simple strategy so that with probability ≥ 1 - Õ(1/√n), the player’s payoff is only a constant factor smaller than the optimal choice (i.e., the one made by the prophet). This competitiveness is somewhat surprising, as both the optimal payoff and this strategy’s payoff are larger by a factor of Θ(log n) than the average payoff.

Neighborhood finders and nearest neighbor queries are fundamental components of sampling-based motion planning (SBMP) algorithms. Using different distance metrics or otherwise changing the definition of a neighborhood produces different algorithms with unique empirical and theoretical properties. In his textbook on planning algorithms, LaValle suggests a neighborhood finder for the Rapidly-exploring Random Tree (RRT) algorithm, which finds the nearest neighbor of the sampled point on theswathof the tree, that is, on the set of all of the points on the tree edges, using a hierarchical data structure. In this paper, we implement such a neighborhood finder and show, theoretically and experimentally, that this results in more efficient algorithms.

We show that a variant of the continuous Fréchet distance between polygonal curves can be computed using essentially the same algorithm used to solve the discrete version. The new variant is not necessarily monotone, but this shortcoming can be easily handled via refinement. Combined with a Dijkstra/Prim type algorithm, this leads to a realization of the Fréchet distance (i.e., a morphing) that is locally optimal (aka locally correct), that is both easy to compute, and in practice, takes near linear time on many inputs. The new morphing has the property that the leash is always as short as possible. These matchings/morphings are more natural, and are better than the ones computed by standard algorithms - in particular, they handle noise more graciously. This should make the Fréchet distance more useful for real world applications. We implemented the new algorithm, and various strategies to obtain fast practical performance. We performed extensive experiments with our new algorithm, and released publicly available (and easily installable and usable) Julia and Python packages. In particular, the Julia implementation, for computing the regular Fréchet distance, seems to be {significantly faster} than other currently available implementations. See Table 2.2. Our algorithms can be used to compute the almost-exact Fréchet distance between polygonal curves. Implementations and numerous examples are available here: https://frechet.xyz.

$ \newcommand{\Re}{\mathbb{R}} \newcommand{\reals}{\mathbb{R}} \newcommand{\SetX}{\mathsf{X}} \newcommand{\rad}{r} \newcommand{\Eps}{\Mh{\mathcal{E}}} \newcommand{\p}{\Mh{p}} \newcommand{\q}{\Mh{q}} \newcommand{\Mh}[1]{#1} \newcommand{\query}{q} \newcommand{\eps}{\varepsilon} \newcommand{\VorX}[1]{\mathcal{V} \pth{#1}} \newcommand{\Polygon}{\mathsf{P}} \newcommand{\IntRange}[1]{[ #1 ]} \newcommand{\Space}{\overline{\mathsf{m}}} \newcommand{\pth}[2][\!]{#1\left({#2}\right)} \newcommand{\polylog}{\mathrm{polylog}} \newcommand{\N}{\mathbb N} \newcommand{\Z}{\mathbb Z} \newcommand{\pt}{p} \newcommand{\distY}[2]{\left\| {#1} - {#2} \right\|} \newcommand{\ptq}{q} \newcommand{\pts}{s}$ For a parameter $\eps \in (0,1)$, we present a new construction of $\eps$-locality-sensitive orderings (

In the classical prophet inequality setting, a gambler is given a sequence of n random variables X₁, … , X_n, taken from known distributions, observes their values in adversarial order and selects one of them, immediately after it is being observed, aiming to select a value that is as high as possible. The classical prophet inequality shows a strategy that guarantees a value at least half of the value of an omniscience prophet that always picks the maximum, and this ratio is optimal. Here, we generalize the prophet inequality, allowing the gambler some additional information about the future that is otherwise privy only to the prophet. Specifically, at any point in the process, the gambler is allowed to query an oracle 𝒪. The oracle responds with a single bit answer: YES if the current realization is greater than the remaining realizations, and NO otherwise. We show that the oracle model with m oracle calls is equivalent to the Top-1-of-(m+1) model when the objective is maximizing the probability of selecting the maximum. This equivalence fails to hold when the objective is maximizing the competitive ratio, but we still show that any algorithm for the oracle model implies an equivalent competitive ratio for the Top-1-of-(m+1) model. We resolve the oracle model for any m, giving tight lower and upper bound on the best possible competitive ratio compared to an almighty adversary. As a consequence, we provide new results as well as improvements on known results for the Top-1-of-m model.

Let B = (b1,…, bn} be a set of n axis-aligned boxes in ℝd where d ≥ 2 is a constant. The piercing problem is to compute a smallest set of points N ∪ ℝd that hits every box in B, i.e., N ∩ bi ≠ ϕ, for i = 1,…, n. The problem is known to be NP-Hard. Let p := p (B), the piercing number be the minimum size of a piercing set of B. We first present a randomized O(log log p)-approximation algorithm with expected running time O(nd/2 polylog(n)). Next, we show that the expected running time can be improved to near-linear using a sampling-based technique, if p = O(n1/(d-1)). Specifically, in the plane, the improved running time is O(n log p), assuming p < n/ logΩ(1) n. Finally, we study the dynamic version of the piercing problem where boxes can be inserted or deleted. For boxes in ℝ2, we obtain a randomized O(log log p)-approximation algorithm with O(n1/2 polylog(n)) amortized expected update time for insertion or deletion of boxes. For squares in ℝ2, the update time can be improved to O(n1/3 polylog(n)).

Let $P$ be a set of $n$ points in $\Re^2$. For a parameter $\varepsilon\in (0,1)$, a subset $C\subseteq P$ is an \emph{$\varepsilon$-kernel} of $P$ if the projection of the convex hull of $C$ approximates that of $P$ within $(1-\varepsilon)$-factor in every direction. The set $C$ is a \emph{weak $\varepsilon$-kernel} of $P$ if its directional width approximates that of $P$ in every direction. Let $\mathsf{k}_{\varepsilon}(P)$ (resp.\ $\mathsf{k}^{\mathsf{w}}_{\varepsilon}(P)$) denote the minimum-size of an $\varepsilon$-kernel (resp. weak $\varepsilon$-kernel) of $P$. We present an $O(n\mathsf{k}_{\varepsilon}(P)\log n)$-time algorithm for computing an $\varepsilon$-kernel of $P$ of size $\mathsf{k}_{\varepsilon}(P)$, and an $O(n^2\log n)$-time algorithm for computing a weak $\varepsilon$-kernel of $P$ of size ${\mathsf{k}}^{\mathsf{w}}_{\varepsilon}(P)$. We also present a fast algorithm for the Hausdorff variant of this problem. In addition, we introduce the notion of \emph{$\varepsilon$-core}, a convex polygon lying inside $\mathsf{ch}(P)$, prove that it is a good approximation of the optimal $\varepsilon$-kernel, present an efficient algorithm for computing it, and use it to compute an $\varepsilon$-kernel of small size.

Given a set of points P and a set of regions 𝒪, an incidence is a pair ( p , θ) ∈ P × 𝒪 such that p ∈ ø. We obtain a number of new results on a classical question in combinatorial geometry: What is the number of incidences (under certain restrictive conditions)? We prove a bound of O ( kn (log n / log log n ) d -1 ) on the number of incidences between n points and n axis-parallel boxes in ℝ d , if no k boxes contain k common points, that is, if the incidence graph between the points and the boxes does not contain K k , k as a subgraph. This new bound improves over previous work, by Basit, Chernikov, Starchenko, Tao, and Tran (2021), by more than a factor of log d n for d > 2. Furthermore, it matches a lower bound implied by the work of Chazelle (1990), for k = 2, thus settling the question for points and boxes. We also study several other variants of the problem. For halfspaces, using shallow cuttings, we get a linear bound in two and three dimensions. We also present linear (or near linear) bounds for shapes with low union complexity, such as pseudodisks and fat triangles. * The full version of the paper can be accessed at https://arxiv.org/abs/2112.14829

For point sets P1,…, Pk, a set of lines L is halving if any face of the arrangement A(L) contains at most |Pi|/2 points of Pi, for all i. We study the problem of computing a halving set of lines of minimal size. Surprisingly, we show a polynomial time algorithm that outputs a halving set of size O(ø3/2), where θ is the size of the optimal solution - this is of interest when ø = o(log2 n). Our solution relies on solving a new variant of the weak ε-net problem for corridors, which we believe to be of independent interest. We also study other variants of this problem, including an alternative “dual” settings, where one needs to introduce a set of guards (i.e., points), such that no convex set avoiding the guards contains more than half the points of each point set.

A spanner is reliable if it can withstand large, catastrophic failures in the network. More precisely, any failure of some nodes can only cause a small damage in the remaining graph in terms of the dilation. In other words, the spanner property is maintained for almost all nodes in the residual graph. Constructions of reliable spanners of near linear size are known in the low-dimensional Euclidean settings. Here, we present new constructions of reliable spanners for planar graphs, trees, and (general) metric spaces.

We present a (1-ε)-approximation algorithms for maximum cardinality matchings in disk intersection graphs - all with near linear running time. We also present an estimation algorithm that returns (1±ε)-approximation to the size of such matchings - this algorithm runs in linear time for unit disks, and O(n log n) for general disks (as long as the density is relatively small).

We develop a general randomized technique for solving implicit linear programming problems, where the collection of constraints are defined implicitly by an underlying ground set of elements. In many cases, the structure of the implicitly defined constraints can be used to obtain faster linear program solvers. We apply this technique to obtain near-optimal algorithms for a variety of fundamental problems in geometry. For a given point set $P$ of size $n$ in $\mathbb{R}^d$, we develop algorithms for computing geometric centers of a point set, including the centerpoint and the Tukey median, and several other more involved measures of centrality. For $d=2$, the new algorithms run in $O(n\log n)$ expected time, which is optimal, and for higher constant $d>2$, the expected time bound is within one logarithmic factor of $O(n^{d-1})$, which is also likely near optimal for some of the problems.

Similarity search is a fundamental algorithmic primitive, widely used in many computer science disciplines. Given a set of points S and a radius parameter r > 0, the r-near neighbor ( r -NN) problem asks for a data structure that, given any query point q , returns a point p within distance at most r from q . In this paper, we study the r -NN problem in the light of individual fairness and providing equal opportunities: all points that are within distance r from the query should have the same probability to be returned. In the low-dimensional case, this problem was first studied by Hu, Qiao, and Tao (PODS 2014). Locality sensitive hashing (LSH) , the theoretically strongest approach to similarity search in high dimensions, does not provide such a fairness guarantee. In this work, we show that LSH based algorithms can be made fair, without a significant loss in efficiency. We propose several efficient data structures for the exact and approximate variants of the fair NN problem. Our approach works more generally for sampling uniformly from a sub-collection of sets of a given collection and can be used in a few other applications. We also develop a data structure for fair similarity search under inner product that requires nearly-linear space and exploits locality sensitive filters. The paper concludes with an experimental evaluation that highlights the unfairness of state-of-the-art NN data structures and shows the performance of our algorithms on real-world datasets.

We study colored coverage and clustering problems. Here, we are given a colored point set where the points are covered by (unknown) $k$ clusters, which are monochromatic (i.e., all the points covered by the same cluster, have the same color). The access to the colors of the points (or even the points themselves) is provided indirectly via various queries (such as nearest neighbor, or separation queries). We show that if the number of clusters is a constant, then one can correctly deduce the color of all the points (i.e., compute a monochromatic clustering of the points) using a polylogarithmic number of queries. We investigate several variants of this problem, including Undecided Linear Programming, covering of points by $k$ monochromatic balls, covering by $k$ triangles/simplices, and terrain simplification. For the later problem, we present the first near linear time approximation algorithm. While our approximation is slightly worse than previous work, this is the first algorithm to have subquadratic complexity if the terrain has "small" complexity.

We study the problem of constructing weak ε-nets where the stabbing elements are lines or k-flats instead of points. We study this problem in the simplest setting where it is still interesting - namely, the uniform measure of volume over the hypercube [0,1]^d. Specifically, a (k,ε)-net is a set of k-flats, such that any convex body in [0,1]^d of volume larger than ε is stabbed by one of these k-flats. We show that for k ≥ 1, one can construct (k,ε)-nets of size O(1/ε^{1-k/d}). We also prove that any such net must have size at least Ω(1/ε^{1-k/d}). As a concrete example, in three dimensions all ε-heavy bodies in [0,1]³ can be stabbed by Θ(1/ε^{2/3}) lines. Note, that these bounds are sublinear in 1/ε, and are thus somewhat surprising.

A spanner is reliable if it can withstand large, catastrophic failures in the network. More precisely, any failure of some nodes can only cause a small damage in the remaining graph in terms of the dilation, that is, the spanner property is maintained for almost all nodes in the residual graph. Constructions of reliable spanners of near linear size are known in the low-dimensional Euclidean settings. Here, we present new constructions of reliable spanners for planar graphs, trees and (general) metric spaces.

$\newcommand{\floor}[1]{\left\lfloor {#1} \right\rfloor} \renewcommand{\Re}{\mathbb{R}}$ Tverberg's theorem states that a set of $n$ points in $\Re^d$ can be partitioned into $\floor{n/(d+1)}$ sets with a common intersection. A point in this intersection (aka Tverberg point) is a centerpoint of the input point set, and the Tverberg partition provides a compact proof of this, which is algorithmically useful. Unfortunately, computing a Tverberg point exactly requires $n^{O(d^2)}$ time. We provide several new approximation algorithms for this problem, which improve either the running time or quality of approximation, or both. In particular, we provide the first strongly polynomial (in both $n$ and $d$) approximation algorithm for finding a Tverberg point.

Consider a set $$P\subseteq \mathbb {R}^d$$ of n points, and a convex body $$C$$ provided via a separation oracle. The task at hand is to decide for each point of $$P$$ if it is in $$C$$ using the fewest number of oracle queries. We show that one can solve this problem in two and three dimensions using queries, where is the size of the largest subset of points of $$P$$ in convex position. In 2D, we provide an algorithm that efficiently generates these adaptive queries. Furthermore, we show that in two dimensions one can solve this problem using oracle queries, where is a lower bound on the minimum number of queries that any algorithm for this specific instance requires. Finally, we consider other variations on the problem, such as using the fewest number of queries to decide if $$C$$ contains all points of $$P$$ . As an application of the above, we show that the discrete geometric median of a point set P in $$\mathbb {R}^2$$ can be computed in expected time.

Let P be a set of n points in R d . For a parameter α ∈ (0,1), an α-centerpoint of P is a point p ∈ R d such that all closed halfspaces containing P also contain at least α n points of P . We revisit an algorithm of Clarkson et al. [1996] that computes (roughly) a 1/(4 d 2 )-centerpoint in Õ( d 9 ) randomized time, where Õ hides polylogarithmic terms. We present an improved algorithm that can compute centerpoints with quality arbitrarily close to 1/ d 2 and runs in randomized time Õ( d 7 ). While the improvements are (arguably) mild, it is the first refinement of the algorithm by Clarkson et al. [1996] in over 20 years. The new algorithm is simpler, and the running time bound follows by a simple random walk argument, which we believe to be of independent interest. We also present several new applications of the improved centerpoint algorithm.

Let P be a set of n points in ℝ^d in general position. A median hyperplane (roughly) splits the point set P in half. The yolk of P is the ball of smallest radius intersecting all median hyperplanes of P. The egg of P is the ball of smallest radius intersecting all hyperplanes which contain exactly d points of P. We present exact algorithms for computing the yolk and the egg of a point set, both running in expected time O(n^(d-1) log n). The running time of the new algorithm is a polynomial time improvement over existing algorithms. We also present algorithms for several related problems, such as computing the Tukey and center balls of a point set, among others.

For any constants $d\ge 1$, $ε>0$, $t>1$, and any $n$-point set $P\subset\mathbb{R}^d$, we show that there is a geometric graph $G=(P,E)$ having $O(n\log^2 n\log\log n)$ edges with the following property: For any $F\subseteq P$, there exists $F^+\supseteq F$, $|F^+| \le (1+ε)|F|$ such that, for any pair $p,q\in P\setminus F^+$, the graph $G-F$ contains a path from $p$ to $q$ whose (Euclidean) length is at most $t$ times the Euclidean distance between $p$ and $q$. In the terminology of robust spanners (Bose \et al, SICOMP, 42(4):1720--1736, 2013) the graph $G$ is a $(1+ε)k$-robust $t$-spanner of $P$. This construction is sparser than the recent constructions of Buchin, Olàh, and Har-Peled (arXiv:1811.06898) who prove the existence of $(1+ε)k$-robust $t$-spanners with $n\log^{O(d)} n$ edges.

We derive fast approximation schemes for LP relaxations of several well-studied geometric optimization problems that include packing, covering, and mixed packing and covering constraints. Previous work in computational geometry concentrated mainly on the rounding stage to prove approximation bounds, assuming that the underlying LPs can be solved efficiently. This work demonstrates that many of those results can be made to run in nearly linear time. In contrast to prior work on this topic our algorithms handle weights and capacities, side constraints, and also apply to mixed packing and covering problems, in a unified fashion. Our framework relies crucially on the properties of a randomized MWU algorithm of [41]; we demonstrate that it is well-suited for range spaces that admit efficient approximate dynamic data structures for emptiness oracles. Our framework cleanly separates the MWU algorithm for solving the LP from the key geometric data structure primitives, and this enables us to handle side constraints in a simple way. Combined with rounding algorithms that can also be implemented efficiently, we obtain the first near-linear constant factor approximation algorithms for several problems.

Abstract We show how to construct a $$(1+\varepsilon )$$ ( 1 + ε ) -spanner over a set $${P}$$ P of n points in $${\mathbb {R}}^d$$ R d that is resilient to a catastrophic failure of nodes. Specifically, for prescribed parameters $${\vartheta },\varepsilon \in (0,1)$$ ϑ , ε ∈ ( 0 , 1 ) , the computed spanner $${G}$$ G has $$\begin{aligned} {{\mathcal {O}}}\bigl (\varepsilon ^{-O(d)} {\vartheta }^{-6} n(\log \log n)^6 \log n \bigr ) \end{aligned}$$ O ( ε - O ( d ) ϑ - 6 n ( log log n ) 6 log n ) edges. Furthermore, for anyk, and any deleted set $${{B}}\subseteq {P}$$ B ⊆ P of k points, the residual graph $${G}\setminus {{B}}$$ G \ B is a $$(1+\varepsilon )$$ ( 1 + ε ) -spanner for all the points of $${P}$$ P except for $$(1+{\vartheta })k$$ ( 1 + ϑ ) k of them. No previous constructions, beyond the trivial clique with $${{\mathcal {O}}}(n^2)$$ O ( n 2 ) edges, were known with this resilience property (i.e., only a tiny additional fraction of vertices, $$\vartheta |B|$$ ϑ | B | , lose their distance preserving connectivity). Our construction works by first solving the exact problem in one dimension, and then showing a surprisingly simple and elegant construction in higher dimensions, that uses the one-dimensional construction in a black-box fashion.

For any constant $d$ and parameter $\varepsilon \in (0,1/2]$, we show the existence of (roughly) $1/\varepsilon^d$ orderings on the unit cube $[0,1)^d$ such that for any two points $p, q\in [0,1)^d$ close together under the Euclidean metric, there is a linear ordering in which all points between $p$ and $q$ in the ordering are “close” to $p$ or $q$. More precisely, the only points that could lie between $p$ and $q$ in the ordering are points with Euclidean distance at most $\varepsilon\left\| {p} - {q} \right\|$ from either $p$ or $q$. These orderings are extensions of the Z-order, and they can be efficiently computed. Functionally, the orderings can be thought of as a replacement to quadtrees and related structures (like well-separated pair decompositions). We use such orderings to obtain surprisingly simple algorithms for a number of basic problems in low-dimensional computational geometry, including (i) dynamic approximate bichromatic closest pair, (ii) dynamic spanners, (iii) dynamic approximate minimum spanning trees, (iv) static and dynamic fault-tolerant spanners, and (v) approximate nearest neighbor search.

We study the task of estimating the number of edges in a graph, where the access to the graph is provided via an independent set oracle. Independent set queries draw motivation from group testing and have applications to the complexity of decision versus counting problems. We give two algorithms to estimate the number of edges in an n -vertex graph, using (i) polylog( n ) bipartite independent set queries or (ii) n 2/3 polylog( n ) independent set queries.

Given a set of n points in the plane, and a parameter k, we consider the problem of computing the minimum (perimeter or area) axis-aligned rectangle enclosing k points. We present the first near quadratic time algorithm for this problem, improving over the previous near-O(n^{5/2})-time algorithm by Kaplan et al. [Haim Kaplan et al., 2017]. We provide an almost matching conditional lower bound, under the assumption that (min,+)-convolution cannot be solved in truly subquadratic time. Furthermore, we present a new reduction (for either perimeter or area) that can make the time bound sensitive to k, giving near O(n k) time. We also present a near linear time (1+epsilon)-approximation algorithm to the minimum area of the optimal rectangle containing k points. In addition, we study related problems including the 3-sided, arbitrarily oriented, weighted, and subset sum versions of the problem.

For any constant d and parameter epsilon > 0, we show the existence of (roughly) 1/epsilon^d orderings on the unit cube [0,1)^d, such that any two points p, q in [0,1)^d that are close together under the Euclidean metric are "close together" in one of these linear orderings in the following sense: the only points that could lie between p and q in the ordering are points with Euclidean distance at most epsilon | p - q | from p or q. These orderings are extensions of the Z-order, and they can be efficiently computed. Functionally, the orderings can be thought of as a replacement to quadtrees and related structures (like well-separated pair decompositions). We use such orderings to obtain surprisingly simple algorithms for a number of basic problems in low-dimensional computational geometry, including (i) dynamic approximate bichromatic closest pair, (ii) dynamic spanners, (iii) dynamic approximate minimum spanning trees, (iv) static and dynamic fault-tolerant spanners, and (v) approximate nearest neighbor search.

In this work we study a "fair" variant of the near neighbor problem. Namely, given a set of $n$ points $P$ and a parameter $r$, the goal is to preprocess the points, such that given a query point $q$, any point in the $r$-neighborhood of the query, i.e., $B(q,r)$, have the same probability of being reported as the near neighbor. We show that LSH based algorithms can be made fair, without a significant loss in efficiency. Specifically, we show an algorithm that reports a point $p$ in the $r$-neighborhood of a query $q$ with almost uniform probability. The time to report such a point is proportional to $O(\dns(q.r) Q(n,c))$, and its space is $O(S(n,c))$, where $Q(n,c)$ and $S(n,c)$ are the query time and space of an LSH algorithm for $c$-approximate near neighbor, and $\dns(q,r)$ is a function of the local density around $q$. Our approach works more generally for sampling uniformly from a sub-collection of sets of a given collection and can be used in a few other applications. Finally, we run experiments to show performance of our approach on real data.

We present a (1+ε)-approximation algorithm with quasi-polynomial running time for computing a maximum weight independent set of polygons from a given set of polygons in the plane. Contrasting this, the best-known polynomial time algorithm for the problem has an approximation ratio of n ε . Surprisingly, we can extend the algorithm to the problem of computing the maximum cardinality subset of the given set of polygons whose intersection graph fulfills some sparsity condition. For example, we show that one can approximate the maximum subset of polygons such that the intersection graph of the subset is planar or does not contain a cycle of length 4 (i.e., K 2,2 ). Our algorithm relies on a recursive partitioning scheme, whose backbone is the existence of balanced cuts with small complexity that intersect polygons from the optimal solution of a small total weight. For the case of large axis-parallel rectangles, we provide a polynomial time (1 + ε)-approximation for the maximum weight independent set. Specifically, we consider the problem where each rectangle has one edge whose length is at least a constant fraction of the length of the corresponding edge of the bounding box of all the input elements. This is now the most general case for which a PTAS is known, and it requires a new and involved partitioning scheme, which should be of independent interest.

For a set P of n points in the unit ball b⊆ R d , consider the problem of finding a small subset T ⊆ P such that its convex-hull ε-approximates the convex-hull of the original set. Specifically, the Hausdorff distance between the convex hull of T and the convex hull of P should be at most ε. We present an efficient algorithm to compute such an ε′-approximation of size k alg , where ε ′ is a function of ε and k alg is a function of the minimum size k opt of such an ε-approximation. Surprisingly, there is no dependence on the dimension d in either of the bounds. Furthermore, every point of P can be ε-approximated by a convex-combination of points of T that is O (1/ε 2 )-sparse. Our result can be viewed as a method for sparse, convex autoencoding: approximately representing the data in a compact way using sparse combinations of a small subset T of the original data. The new algorithm can be kernelized, and it preserves sparsity in the original input.

In this paper we study an experimentally-observed connection between two seemingly unrelated processes, one from computational geometry and the other from differential geometry. The first one (which we call grid peeling) is the convex-layer decomposition of subsets G ⊂ ℤ2 of the integer grid, previously studied for the particular case G = {1, …, m}2 by Har-Peled and Lidický (2013). The second one is the affine curve-shortening flow (ACSF), first studied by Alvarez et al. (1993) and Sapiro and Tannenbaum (1993). We present empirical evidence that, in a certain well-defined sense, grid peeling behaves at the limit like ACSF on convex curves. We offer some theoretical arguments in favor of this conjecture. We also pay closer attention to the simple case where G = ℕ2 is a quarter-infinite grid. This case corresponds to ACSF starting with an infinite L-shaped curve, which when transformed using the ACSF becomes a hyperbola for all times t > 0. We prove that, in the grid peeling of ℕ2, (1) the number of grid points removed up to iteration n is Θ(n3/2 log n); and (2) the boundary at iteration n is sandwiched between two hyperbolas that are separated from each other by a constant factor.

In the Sparse Linear Regression (SLR) problem, given a $d \times n$ matrix $M$ and a $d$-dimensional query $q$, the goal is to compute a $k$-sparse $n$-dimensional vector $τ$ such that the error $||M τ-q||$ is minimized. This problem is equivalent to the following geometric problem: given a set $P$ of $n$ points and a query point $q$ in $d$ dimensions, find the closest $k$-dimensional subspace to $q$, that is spanned by a subset of $k$ points in $P$. In this paper, we present data-structures/algorithms and conditional lower bounds for several variants of this problem (such as finding the closest induced $k$ dimensional flat/simplex instead of a subspace). In particular, we present approximation algorithms for the online variants of the above problems with query time $\tilde O(n^{k-1})$, which are of interest in the "low sparsity regime" where $k$ is small, e.g., $2$ or $3$. For $k=d$, this matches, up to polylogarithmic factors, the lower bound that relies on the affinely degenerate conjecture (i.e., deciding if $n$ points in $\mathbb{R}^d$ contains $d+1$ points contained in a hyperplane takes $Ω(n^d)$ time). Moreover, our algorithms involve formulating and solving several geometric subproblems, which we believe to be of independent interest.

Suppose we are given a set D of n pairwise intersecting disks in the plane. A planar point set P stabs D if and only if each disk in D contains at least one point from P. We present a deterministic algorithm that takes O(n) time to find five points that stab D. Furthermore, we give a simple example of 13 pairwise intersecting disks that cannot be stabbed by three points. This provides a simple - albeit slightly weaker - algorithmic version of a classical result by Danzer that such a set D can always be stabbed by four points.

Given a set P of n points in the plane, its separability is the minimum number of lines needed to separate all its pairs of points from each other. We show that the minimum number of lines needed to separate n points, picked randomly (and uniformly) in the unit square, is , where hides polylogarithmic factors. In addition, we provide a fast approximation algorithm for computing the separability of a given point set in the plane. Finally, we point out the connection between separability and partitions.

Given a set of n disjoint balls $$b_1, \dots , b_n$$ in $$\mathrm{I\! R}^d$$ , we provide a data structure of near linear size that can answer $$(1\pm {\varepsilon })$$ -approximate kth-nearest neighbor queries on the balls in $$O(\log n + 1/{\varepsilon }^d)$$ time, where k and $${\varepsilon }$$ may be provided at query time. If k and $${\varepsilon }$$ are provided in advance, we provide a data structure to answer such queries requiring O(n / k) space; that is, the data structure requires sublinear space if k is sufficiently large.

We introduce a new variant of the nearest neighbor search problem, which allows for some coordinates of the dataset to be arbitrarily corrupted or unknown. Formally, given a dataset of n points P = {x1,…, xn} in high-dimensions, and a parameter k, the goal is to preprocess the dataset, such that given a query point q, one can compute quickly a point x ∊ P, such that the distance of the query to the point x is minimized, when ignoring the “optimal” k coordinates. Note, that the coordinates being ignored are a function of both the query point and the point returned. We present a general reduction from this problem to answering ANN queries, which is similar in spirit to LSH (locality sensitive hashing) [19]. Specifically, we give a sampling technique which achieves a bi-criterion approximation for this problem. If the distance to the nearest neighbor after ignoring k coordinates is r, the data-structure returns a point that is within a distance of O(r) after ignoring O(k) coordinates. We also present other applications and further extensions and refinements of the above result. The new data-structures are simple and (arguably) elegant, and should be practical - specifically, all bounds are polynomial in all relevant parameters (including the dimension of the space, and the robustness parameter k).

We study the problem of discrete geometric packing. Here, given weighted regions (say, in the plane) and points (with capacities), one has to pick a maximum weight subset of the regions such that no point is covered more than its capacity. We provide a general framework and an algorithm for approximating the optimal solution for packing in hypergraphs arising out of such geometric settings. Using this framework we get a flotilla of results on this problem (and also on its dual, where one wants to pick a maximum weight subset of the points when the regions have capacities). For example, for the case of fat triangles of similar size, we show an $O(1)$-approximation and prove that no PTAS is possible.

We investigate the family of intersection graphs of low density objects in low dimensional Euclidean space. This family is quite general, includes planar graphs, and in particular is a subset of the family of graphs that have polynomial expansion. We present efficient $(1+\varepsilon)$-approximation algorithms for polynomial expansion graphs for unweighted Independent Set, Set Cover, and Dominating Set problems, among others, and these results seem to be new. Naturally, PTASs for these problems are known for subclasses of this graph family. These results have immediate applications in the geometric domain. For example, the new algorithms yield the only PTAS known for covering points by fat triangles (that are shallow). We also prove corresponding hardness of approximation for some of these optimization problems, characterizing their intractability with respect to density. For example, we show that there is no PTAS for covering points by fat triangles if they are not shallow, thus matching our PTAS for this problem with respect to depth.

Given a set P of n points in R^d , we show how to insert a set Z of O(n^(1-1/d)) additional points, such that P can be broken into two sets P1 and P2 , of roughly equal size, such that in the Voronoi diagram V(P u Z), the cells of P1 do not touch the cells of P2; that is, Z separates P1 from P2 in the Voronoi diagram (and also in the dual Delaunay triangulation). In addition, given such a partition (P1,P2) of P , we present an approximation algorithm to compute a minimum size separator realizing this partition. We also present a simple local search algorithm that is a PTAS for approximating the optimal Voronoi partition.

We consider the classic Set Cover problem in the data stream model. For n elements and m sets (m ≥ n) we give a O(1/δ)-pass algorithm with a strongly sub-linear ~O(mnδ) space and logarithmic approximation factor. This yields a significant improvement over the earlier algorithm of Demaine et al. [10] that uses exponentially larger number of passes. We complement this result by showing that the tradeoff between the number of passes and space exhibited by our algorithm is tight, at least when the approximation factor is equal to 1. Specifically, we show that any algorithm that computes set cover exactly using ({1 over 2δ}-1) passes must use ~Ω(mnδ) space in the regime of m=O(n). Furthermore, we consider the problem in the geometric setting where the elements are points in R2 and sets are either discs, axis-parallel rectangles, or fat triangles in the plane, and show that our algorithm (with a slight modification) uses the optimal ~O(n) space to find a logarithmic approximation in O(1/δ) passes.

For a set P of n points in the unit ball b ⊆ ℝd, consider the problem of finding a small subset T ⊆ P such that its convex-hull ∊-approximates the convex-hull of the original set. Specifically, the Hausdorff distance between the convex hull of T and the convex hull of P should be at most ∊. We present an efficient algorithm to compute such an ∊′-approximation of size kalg, where ∊′ is a function of ∊, and kalg is a function of the minimum size kopt of such an ∊-approximation. Surprisingly, there is no dependence on the dimension d in either of the bounds. Furthermore, every point of P can be ∊-approximated by a convex-combination of points of T that is O(1/∊2)-sparse. Our result can be viewed as a method for sparse, convex autoencoding: approximately representing the data in a compact way using sparse combinations of a small subset T of the original data. The new algorithm can be kernelized, and it preserves sparsity in the original input.

Let H be a set of n non-vertical planes in three dimensions, and let r < n be a parameter. We give a simple alternative proof of the existence of a O(1/r)-cutting of the first n/r levels of (H), which consists of O(r) semi-unbounded vertical triangular prisms. The same construction yields an approximation of the (n/r)-level by a terrain consisting of O(r/∊3) triangular faces, which lies entirely between the levels (1 ± ∊)n/r. The proof does not use sampling, and exploits techniques based on planar separators and various structural properties of levels in three-dimensional arrangements and of planar maps. The proof is constructive, and leads to a simple randomized algorithm, that computes the terrain in O(n + r2∊–6 log3 r) expected time. An application of this technique allows us to mimic Matoušek's construction of cuttings in the plane [36], to obtain a similar construction of “layered” (1/r)-cutting of the entire arrangement (H), of optimal size O(r3). Another application is a simplified optimal approximate range counting algorithm in three dimensions, competing with that of Afshani and Chan [1].

Nearest-neighbor search, which returns the nearest neighbor of a query point in a set of points, is an important and widely studied problem in many fields, and it has a wide range of applications. In many of them, such as sensor databases, location-based services, face recognition, and mobile data, the location of data is imprecise. We therefore study nearest-neighbor queries in a probabilistic framework in which the location of each input point is specified as a probability distribution function. We present efficient algorithms for (i) computing all points that are nearest neighbors of a query point with nonzero probability and (ii) estimating the probability of a point being the nearest neighbor of a query point, either exactly or within a specified additive error.

We investigate the combinatorial complexity of geodesic Voronoi diagrams on polyhedral terrains using a probabilistic analysis. Aronov et al. [2008] prove that, if one makes certain realistic input assumptions on the terrain, this complexity is Θ( n + m √ n ) in the worst case, where n denotes the number of triangles that define the terrain and m denotes the number of Voronoi sites. We prove that, under a relaxed set of assumptions, the Voronoi diagram has expected complexity O ( n + m ), given that the sites are sampled uniformly at random from the domain of the terrain (or the surface of the terrain). Furthermore, we present a construction of a terrain that implies a lower bound of Ω( nm 2/3 ) on the expected worst-case complexity if these assumptions on the terrain are dropped. As an additional result, we show that the expected fatness of a cell in a random planar Voronoi diagram is bounded by a constant.

We present an extension of Voronoi diagrams where not only the distance to the site is taken into account when considering which site the client is going to use, but additional attributes (i.e., prices or weights) are also considered. A cell in this diagram is then the loci of all clients that consider the same set of sites to be relevant. In particular, the precise site a client might use from this candidate set depends on parameters that might change between usages, and the candidate set lists all of the relevant sites. The resulting diagram is significantly more expressive than Voronoi diagrams, but naturally has the drawback that its complexity, even in the plane, might be quite high. Nevertheless, we show that if the attributes of the sites are drawn from the same distribution (note that the locations are fixed), then the expected complexity of the candidate diagram is near linear. To this end, we derive several new technical results, which are of independent interest.

We resolve an open problem due to Tetsuo Asano, showing how to compute the shortest path in a polygon, given in a read only memory, using sublinear space and subquadratic time. Specifically, given a simple polygon P with n vertices in a read only memory, and additional working memory of size m, the new algorithm computes the shortest path (in P) in O(n^2 / m) expected time, assuming m = O(n / log^2 n). This requires several new tools, which we believe to be of independent interest. Specifically, we show that violator space problems, an abstraction of low dimensional linear-programming (and LP-type problems), can be solved using constant space and expected linear time, by modifying Seidel's linear programming algorithm and using pseudo-random sequences.

We investigate what computational tasks can be performed on a point set in R^d, if we are only given black-box access to it via nearest-neighbor search. This is a reasonable assumption if the underlying point set is either provided implicitly, or it is stored in a data structure that can answer such queries. In particular, we show the following: (A) One can compute an approximate bi-criteria k-center clustering of the point set, and more generally compute a greedy permutation of the point set. (B) One can decide if a query point is (approximately) inside the convex-hull of the point set. We also investigate the problem of clustering the given point set, such that meaningful proximity queries can be carried out on the centers of the clusters, instead of the whole point set.

We provide a general framework for getting expected linear time constant factor approximations (and in many cases FPTAS's) to several well known problems in Computational Geometry, such as k -center clustering and farthest nearest neighbor. The new approach is robust to variations in the input problem, and yet it is simple, elegant, and practical. In particular, many of these well studied problems which fit easily into our framework, either previously had no linear time approximation algorithm, or required rather involved algorithms and analysis. A short list of the problems we consider include farthest nearest neighbor, k -center clustering, smallest disk enclosing k points, k th largest distance, k th smallest m -nearest neighbor distance, k th heaviest edge in the MST and other spanning forest type problems, problems involving upward closed set systems, and more. Finally, we show how to extend our framework such that the linear running time bound holds with high probability.

We investigate the classes of functions whose minimization diagrams can be approximated efficiently in $\mathbb{R}^d$. We present a general framework and a data-structure that can be used to approximate the minimization diagram of such functions. The resulting data-structure has near linear size and can answer queries in logarithmic time. Applications include approximating the Voronoi diagram of multiplicatively weighted points, but the new technique also works for more general distance functions. For example, we get such data-structures for metrics induced by convex bodies, and the nearest furthest-neighbor distance to a set of point sets. Interestingly, our framework also works for distance functions that do not obey the triangle inequality. For many of these functions no near linear size approximation was known before.

We describe how to approximate, in quasi-polynomial time, the largest independent set of polygons, in a given set of polygons. Our algorithm works by extending the result of Adamaszek and Wiese [1, 2] to polygons of arbitrary complexity. Surprisingly, the algorithm also works for computing the largest subset of the given set of polygons that has some sparsity condition. For example, we show that one can approximate the largest subset of polygons, such that the intersection graph of the subset does not contain a cycle of length 4 (i.e., K2,2).

In this paper, we provide an O(n polylog n) bound on the expected complexity of the randomly weighted Voronoi diagram of a set of n sites in the plane, where the sites can be either points, interior-disjoint convex sets, or other more general objects. Here the randomness is on the weight of the sites, not their location. This compares favorably with the worst case complexity of these diagrams, which is quadratic. As a consequence we get an alternative proof to that of Agarwal et al. [AHKS13] of the near linear complexity of the union of randomly expanded disjoint segments or convex sets (with an improved bound on the latter). The technique we develop is elegant and should be applicable to other problems.

For a set of $n$ points in $\mathbb{R}^d$, and parameters $k$ and $\varepsilon$, we present a data structure that answers $(1+\varepsilon,k)$ approximate nearest neighbor queries in logarithmic time. Surprisingly, the space used by the data structure is $\widetilde{O}(n /k)$, where the $\widetilde{O}(\cdot)$ notation here hides terms that are exponential in $d$, roughly varying as $1/\varepsilon^d$; as such, the space used is sublinear in the input size if $k$ is sufficiently large. Our approach provides a novel way to summarize geometric data, such that meaningful proximity queries on the data can be carried out using this sketch. Using this, we provide a sublinear space data structure that can estimate the density of a point set under various measures, including (i) sum of distances of $k$ closest points to the query point and (ii) sum of squared distances of $k$ closest points to the query point. Our approach generalizes to other distance-based estimations of densities of similar flavor. We also study the problem of approximating some of these quantities when using sampling. In particular, we show that a sample of size $\widetilde{O} (n /k)$ is sufficient, in some restricted cases, to estimate the above quantities. Remarkably, the sample size has only linear dependency on the dimension.

Given two simplicial complexes in R d and start and end vertices in each complex, we show how to compute curves (in each complex) between these vertices, such that the weak Fréchet distance between these curves is minimized. As a polygonal curve is a complex, this generalizes the regular notion of weak Fréchet distance between curves. We also generalize the algorithm to handle an input of k simplicial complexes. Using this new algorithm, we can solve a slew of new problems, from computing a mean curve for a given collection of curves to various motion planning problems. Additionally, we show that for the mean curve problem, when the k input curves are c -packed, one can (1+ε-approximate the mean curve in near-linear time, for fixed k and ε. Additionally, we present an algorithm for computing the strong Fréchet distance between two curves, which is simpler than previous algorithms and avoids using parametric search.

We investigate the classes of functions whose minimization diagrams can be approximated efficiently in Red. We present a general framework and a data-structure that can be used to approximate the minimization diagram of such functions. The resulting data-structure has near linear size and can answer queries in logarithmic time. Applications include approximating the Voronoi diagram of (additively or multiplicatively) weighted points. Our technique also works for more general distance functions, such as metrics induced by convex bodies, and the nearest furthest-neighbor distance to a set of point sets. Interestingly, our framework works also for distance functions that do not obey the triangle inequality. For many of these functions no near-linear size approximation was known before.

Nearest-neighbor (NN) search, which returns the nearest neighbor of a query point in a set of points, is an important and widely studied problem in many fields, and it has wide range of applications. In many of them, such as sensor databases, location-based services, face recognition, and mobile data, the location of data is imprecise. We therefore study nearest neighbor queries in a probabilistic framework in which the location of each input point is specified as a probability distribution function. We present efficient algorithms for (i) computing all points that are nearest neighbors of a query point with nonzero probability; (ii) estimating, within a specified additive error, the probability of a point being the nearest neighbor of a query point; (iii) using it to return the point that maximizes the probability being the nearest neighbor, or all the points with probabilities greater than some threshold to be the NN. We also present some experimental results to demonstrate the effectiveness of our approach.

A classical result in metric geometry asserts that any n-point metric admits a linear-size spanner of dilation O(log n) [PS89]. More generally, for any c > 1, any metric space admits a spanner of size O(n1+1/c), and dilation at most c. This bound is tight assuming the well-known girth conjecture of Erdős [Erd63]. We show that for a metric induced by a set of n points in high-dimensional Euclidean space, it is possible to obtain improved dilation/size trade-offs. More specifically, we show that any n-point Euclidean metric admits a near-linear size spanner of dilation O(√log n). Using the LSH scheme of Andoni and Indyk [AI06] we further show that for any c > 1, there exist spanners of size roughly O(n1+1/c2) and dilation O(c). Finally, we also exhibit super-linear lower bounds on the size of spanners with constant dilation.

We provide a general framework for getting linear time constant factor approximations (and in many cases FPTAS's) to a copious amount of well known and well studied problems in Computational Geometry, such as k-center clustering and furthest nearest neighbor. The new approach is robust to variations in the input problem, and yet it is simple, elegant and practical. In particular, many of these well studied problems which fit easily into our framework, either previously had no linear time approximation algorithm, or required rather involved algorithms and analysis. A short list of the problems we consider include furthest nearest neighbor, k-center clustering, smallest disk enclosing k points, k-th largest distance, k-th smallest m-nearest neighbor distance, k-th heaviest edge in the MST and other spanning forest type problems, problems involving upward closed set systems, and more. Finally, we show how to extend our framework such that the linear running time bound holds with high probability.

In this paper we show that dimensionality reduction (i.e., Johnson--Lindenstrauss lemma) preserves not only the distances between static points, but also between moving points, and more generally between low-dimensional flats, polynomial curves, curves with low winding degree, and polynomial surfaces. We also show that surfaces with bounded doubling dimension can be embedded into low dimension with small additive error. Finally, we show that for points with polynomial motion, the radius of the smallest enclosing ball can be preserved under dimensionality reduction.

The similarity of two polygonal curves can be measured using the Fréchet distance. We introduce the notion of a more robust Fréchet distance, where one is allowed to shortcut between vertices of one of the curves. This is a natural approach for handling noise, in particular batched outliers. We compute a $(3+\varepsilon)$-approximation to the minimum Fréchet distance over all possible such shortcuts, in near linear time, if the curve is $c$-packed and the number of shortcuts is either small or unbounded. To facilitate the new algorithm we develop several new tools: (a) a data structure for preprocessing a curve (not necessarily $c$-packed) that supports $(1+\varepsilon)$-approximate Fréchet distance queries between a subcurve (of the original curve) and a line segment; (b) a near linear time algorithm that computes a permutation of the vertices of a curve, such that any prefix of $2k-1$ vertices of this permutation forms an optimal approximation (up to a constant factor) to the original curve compared to any polygonal curve with $k$ vertices, for any $k > 0$; and (c) a data structure for preprocessing a curve that supports approximate Fréchet distance queries between a subcurve and query polygonal curve. The query time depends quadratically on the complexity of the query curve and only (roughly) logarithmically on the complexity of the original curve. To our knowledge, these are the first data structures to support these kind of queries efficiently.

We study the approximate nearest neighbor problem for metric spaces where the query points are constrained to lie on a subspace of low doubling dimension, while the data is high dimensional. We show that this problem can be solved efficiently despite the high dimensionality of the data.

Consider the set of points formed by the integer $n\times n$ grid and the process that in each iteration removes from the point set the vertices of its convex hull. Here, we prove that the number of iterations of this process is $O\!\left(n^{4/3}\right)$; that is, the number of convex layers of the $n\times n$ grid is $\Theta\!\left(n^{4/3}\right)$.

We investigate the combinatorial complexity of geodesic Voronoi diagrams on polyhedral terrains using a probabilistic analysis. Aronov et.al. [abt-cbvdrt-08] prove that, if one makes certain realistic input assumptions on the terrain, this complexity is Θ(n + m √n) in the worst case, where n denotes the number of triangles that define the terrain and m denotes the number of Voronoi sites. We prove that under a relaxed set of assumptions the Voronoi diagram has expected complexity O(n+m), given that the sites have a uniform distribution on the domain of the terrain (or the surface of the terrain). Furthermore, we present a worst-case construction of a terrain which implies a lower bound of Ω(n m2/3) on the expected worst-case complexity if these assumptions on the terrain are dropped.

We study the problem of discrete geometric packing. Here, given weighted regions (say in the plane) and points (with capacities), one has to pick a maximum weight subset of the regions such that no point is covered more than its capacity. We provide a general framework and an algorithm for approximating the optimal solution for packing in hypergraphs arising out of such geometric settings. Using this framework we get a flotilla of results on this problem (and also on its dual, where one wants to pick a maximum weight subset of the points when the regions have capacities). For example, for the case of fat triangles of similar size, we show an (1)-approximation and prove that no PTAS is possible. See [ehr-gpnuc-11] for the full version of the paper.

We describe a O(log n)-approximation algorithm for computing the homotopic Frechet distance between two polygonal curves that lie on the boundary of a triangulated topological disk. Prior to this work, algorithms where known only for curves on the Euclidean plane with polygonal obstacles.

For a set of n points in Rd, and parameters k and e, we present a data structure that answers (1 + e)-approximate k nearest neighbor queries in logarithmic time. Surprisingly, the space used by the data-structure is Õ(n/k), that is, the space used is sub linear in the input size if k is sufficiently large. Our approach provides a novel way to summarize geometric data, such that meaningful proximity queries on the data can be carried out using this sketch. Using this we provide a sub linear space data-structure that can estimate the density of a point set under various measures, including: (i) sum of distances of k closest points to the query point, and (ii) sum of squared distances of k closest points to the query point. Our approach generalizes to other distance based estimation of densities of similar flavor.

The similarity of two polygonal curves can be measured using the Fréchet distance. We introduce the notion of a more robust Fréchet distance, where one is allowed to shortcut between vertices of one of the curves. This is a natural approach for handling noise, in particular batched outliers. We compute a constant factor approximation to the minimum Fréchet distance over all possible such shortcuts. Our algorithm runs in O(c2 kn log3 n) time if one is allowed to take at most k shortcuts and the input curves are c-packed. For the case where the number of shortcuts is unrestricted, we describe an algorithm which runs in O(c2 n log3 n) time. To facilitate the new algorithm we develop several new data-structures, which we believe to be of independent interest: (i) for range reporting on a curve, and (ii) for preprocessing a curve to answer queries for the Fréchet distance between a subcurve and a line segment.

We consider the set multicover problem in geometric settings. Given a set of points P and a collection of geometric shapes (or sets) F , we wish to find a minimum cardinality subset of F such that each point p ∈ P is covered by (contained in) at least d(p) sets. Here, d(p) is an integer demand (requirement) for p. When the demands d(p) = 1 for all p, this is the standard set cover problem. The set cover problem in geometric settings admits an approximation ratio that is better than that for the general version. In this article, we show that similar improvements can be obtained for the multicover problem as well. In particular, we obtain an O (log opt) approximation for set systems of bounded VC-dimension, and an O (1) approximation for covering points by half-spaces in three dimensions and for some other classes of shapes.

Given two simplicial complexes in Rd, and start and end vertices in each complex, we show how to compute curves (in each complex) between these vertices, such that the Frechet distance between these curves is minimized. As a polygonal curve is a complex, this generalizes the regular notion of weak Frechet distance between curves. We also generalize the algorithm to handle an input of k simplicial complexes. Using this new algorithm we can solve a slew of new problems, from computing a mean curve for a given collection of curves, to various motion planning problems. Additionally, we show that for the mean curve problem, when the k input curves are c-packed, one can (1+epsilon)-approximate the mean curve in near linear time, for fixed k and epsilon.

An approximate distance query data structure is a compact representation of a graph, and can be queried to approximate shortest paths between any pair of vertices. Any such data structure that retrieves stretch 2k Ω 1 paths must require space Ω(n1+1/k) for graphs of n nodes. The hard cases that enforce this lower bound are, however, rather dense graphs with average degree Ω(n1/k). We present data structures that, for sparse graphs, substantially break that lower bound barrier at the expense of higher query time. For instance, general graphs require O(n3/2) space and constant query time for stretch 3 paths. For the realistic scenario of a graph with average degree Θ(log n), special cases of our data structures retrieve stretch 2 paths with O(n3/2) space and stretch 3 paths with O̅(n) space, albeit at the cost of O̅(√n) query time. Moreover, supported by large-scale simulations on graphs including the AS-level Internet graph, we argue that our stretch-2 scheme would be simple and efficient to implement as a distributed compact routing protocol.

We study the Approximate Nearest Neighbor problem for metric spaces where the query points are constrained to lie on a subspace of low doubling dimension, while the data is high-dimensional. We show that this problem can be solved efficiently despite the high dimensionality of the data.

We present a new optimal construction of semi-separated pair decomposition (SSPD) for a set of n points in IRd. In the new construction each point participates in a few pairs, and it extends easily to spaces with low doubling dimension. This is the first optimal construction with these properties. As an application of the new construction, for a fixed t > 1, we present a new construction of a t-spanner with O(n) edges and maximum degree O(log2 n) that has a separator of size O(n1-1/d).

We present a simple and practical (1+ε)-approximation algorithm for the Fréchet distance between polygonal curves. To analyze this algorithm we introduce a new realistic family of curves, c-packed curves, that is closed under simplification. We believe the notion of c-packed curves to be of independent interest. We show that our algorithm has near linear running time for c-packed polygonal curves, and show similar results for other input models, such as low density.

We study the shape matching problem under the Hausdorff distance and its variants. In the first part of the article, we consider two sets A,B of balls in R d , d =2,3, and wish to find a translation t that minimizes the Hausdorff distance between A+t , the set of all balls in A shifted by t , and B . We consider several variants of this problem. First, we extend the notion of Hausdorff distance from sets of points to sets of balls, so that each ball has to be matched with the nearest ball in the other set. We also consider the problem in the standard setting, by computing the Hausdorff distance between the unions of the two sets (as point sets). Second, we consider either all possible translations t (as is the standard approach), or consider only translations that keep the balls of A+t disjoint from those of B . We propose several exact and approximation algorithms for these problems. In the second part of the article, we note that the Hausdorff distance is sensitive to outliers, and thus consider two variants that are more robust: the root-mean-square (rms) and the summed Hausdorff distance. We propose efficient approximation algorithms for computing the minimum rms and the minimum summed Hausdorff distances under translation, between two point sets in R d . In order to obtain a fast algorithm for the summed Hausdorff distance, we propose a deterministic efficient dynamic data structure for maintaining an ϵ-approximation of the 1-median of a set of points in R d , under insertions and deletions.

We present approximation algorithms for maximum independent set of pseudo-disks in the plane, both in the weighted and unweighted cases. For the unweighted case, we prove that a local search algorithm yields a PTAS. For the weighted case, we suggest a novel rounding scheme based on an LP relaxation of the problem, that leads to a constant-factor approximation. Most previous algorithms for maximum independent set (in geometric settings) relied on packing arguments that are not applicable in this case. As such, the analysis of both algorithms requires some new combinatorial ideas, which we believe to be of independent interest.

We consider the set multi-cover problem in geometric settings. Given a set of points P and a collection of geometric shapes (or sets) F, we wish to find a minimum cardinality subset of F such that each point p ∈ P is covered by (contained in) at least demands d(p) sets. Here demands d(p) is an integer demand (requirement) for p. When the demands demands d(p)=1 for all p, this is the standard set cover problem. The set cover problem in geometric settings admits an approximation ratio that is better than that for the general version. In this paper, we show that similar improvements can be obtained for the multi-cover problem as well. In particular, we obtain an O(log Opt) approximation for set systems of bounded VC-dimension, and an O(1) approximation for covering points by half-spaces in three dimensions and for some other classes of shapes.

We study the question of finding a deepest point in an arrangement of regions and provide a fast algorithm for this problem using random sampling, showing it sufficient to solve this problem when the deepest point is shallow. This implies, among other results, a fast algorithm for approximately solving linear programming problems with violations. We also use this technique to approximate the disk covering the largest number of red points, while avoiding all the blue points, given two such sets in the plane. Using similar techniques implies that approximate range counting queries have roughly the same time and space complexity as emptiness range queries.

We consider the rooted orienteering problem: Given a set P of n points in the plane, a starting point $r \in P$, and a length constraint B, one needs to find a path starting from r that visits as many points of P as possible and of length not exceeding B. We present a $(1-\varepsilon)$-approximation algorithm for this problem that runs in $n^{O(1/\varepsilon)}$ time; the computed path visits at least $ (1-\varepsilon)k_{\mathrm{opt}}$ points of P, where $k_{\mathrm{opt}}$ is the number of points visited by an optimal solution. This is the first polynomial time approximation scheme for this problem. The algorithm also works in higher dimensions.

In this paper we show that dimensionality reduction (i.e., Johnson-Lindenstrauss lemma) preserves not only the distances between static points, but also between moving points, and more generally between low-dimensional flats, polynomial curves, curves with low winding degree, and polynomial surfaces. We also show that surfaces with bounded doubling dimension can be embedded into low dimension with small additive error. Finally, we show that for points with polynomial motion, the radius of the smallest enclosing ball can be preserved under dimensionality reduction.

The paper consists of two major parts. In the first part, we re-examine relative ε-approximations, previously studied in [12, 13, 18, 25], and their relation to certain geometric problems, most notably to approximate range counting. We give a simple constructive proof of their existence in general range spaces with finite VC dimension, and of a sharp bound on their size, close to the best known one. We then give a construction of smaller-size relative ε-approximations for range spaces that involve points and halfspaces in two and higher dimensions. The planar construction is based on a new structure--spanning trees with small relative crossing number, which we believe to be of independent interest. In the second part, we consider the approximate halfspace range-counting problem in Rd with relative error ε, and show that relative ε-approximations, combined with the shallow partitioning data structures of Matoušek, yields efficient solutions to this problem. For example, one of our data structures requires linear storage and O(n1+δ) preprocessing time, for any δ>0, and answers a query in time O(ε-γn1-1/⌊ d/2 ⌋ 2b log* n), for any γ > 2/⌊ d/2⌋ the choice of γ and δ affects b and the implied constants. Several variants and extensions are also discussed.

We consider the orienteering problem: Given a set P of n points in the plane, a starting point r ∈ P, and a length constraint B, one needs to find a tour starting at r that visits as many points of P as possible and of length not exceeding B. We present a (1−ε)-approximation algorithm for this problem that runs in nO(1/ε) time, and visits at least (1−ε)kopt points of P, where kopt is the number of points visited by the optimal solution. This is the first polynomial time approximation scheme (PTAS) for this problem. The algorithm also works in higher dimensions.

In this paper, we study the problem of L1-fitting a shape to a set of n points in Rd (where d is a fixed constant), where the target is to minimize the sum of distances of the points to the shape, or alternatively the sum of squared distances. We present a general technique for computing a (1+ε)-approximation for such a problem, with running time O(n+poly(log n, 1/ε)), where poly(log n, 1/ε) is a polynomial of constant degree of log n and 1/ε (the power of the polynomial is a function of d). This is a linear time algorithm for a fixed ε>0, and is the first subquadratic algorithm for this problem.Applications of the algorithm include best fitting either a circle, a sphere or a cylinder to a set of points when minimizing the sum of distances (or squared distances) to the respective shape.

We present a near linear time algorithm for constructing hierarchical nets in finite metric spaces with constant doubling dimension. This data-structure is then applied to obtain improved algorithms for the following problems: approximate nearest neighbor search, well-separated pair decomposition, spanner construction, compact representation scheme, doubling measure, and computation of the (approximate) Lipschitz constant of a function. In all cases, the running (preprocessing) time is near linear and the space being used is linear.

This paper study two problems that arise in optimization of sensor networks: First, we devise provable approximation schemes for locating a base station and constructing a network among a set of sensors each of which has a data stream to get to the base station. Subject to power constraints at the sensors, our goal is to locate the base station and establish a network in order to maximize the lifespan of the network. Second, we study optimal sensor placement problems for quality coverage of given domains cluttered with obstacles. We assume "line-of-site", sensors, that sense a point only if the straight segment connecting the sensor to this point (the "line-of-site") does not cross any obstacle. so obstacles occludes area from using line-of-site sensors, the goal is to minimize the number of sensors required in order to have each point "well covered" according to precise criteria (e.g., that each point is seen by two sensors that form at least angle a, or that each point is seen by three sensors that form a triangle containing the point).

In this paper, we show that there exists a (k, ε)-coreset for k-median and k-means clustering of n points in Rd, which is of size independent of n. In particular, we construct a (k, ε)-coreset of size O(k2/εd) for k-median clustering, and of size O(k3/εd+1) for k-means clustering.

We present a near linear time algorithm for constructing hierarchical nets in finite metric spaces with constant doubling dimension. This data-structure is then applied to obtain improved algorithms for the following problems: Approximate nearest neighbor search, well-separated pair decomposition, spanner construction, compact representation scheme, doubling measure, and computation of the (approximate) Lipschitz constant of a function. In all cases, the running (preprocessing) time is near-linear and the space being used is linear.

We propose a new refinement algorithm to generate size-optimal quality-guaranteed Delaunay triangulations in the plane. The algorithm takes O(n log n + m) time, where n is the input size and m is the output size. This is the first time-optimal Delaunay refinement algorithm.

We study generalization properties of the area under the ROC curve (AUC), a quantity that has been advocated as an evaluation criterion for the bipartite ranking problem. The AUC is a different term than the error rate used for evaluation in classification problems; consequently, existing generalization bounds for the classification error rate cannot be used to draw conclusions about the AUC. In this paper, we define the expected accuracy of a ranking function (analogous to the expected error rate of a classification function), and derive distribution-free probabilistic bounds on the deviation of the empirical AUC of a ranking function (observed on a finite data sequence) from its expected accuracy. We derive both a large deviation bound, which serves to bound the expected accuracy of a ranking function in terms of its empirical AUC on a test sequence, and a uniform convergence bound, which serves to bound the expected accuracy of a learned ranking function in terms of its empirical AUC on a training sequence. Our uniform convergence bound is expressed in terms of a new set of combinatorial parameters that we term the bipartite rank-shatter coefficients; these play the same role in our result as do the standard VC-dimension related shatter coefficients (also known as the growth function) in uniform convergence results for the classification error rate. A comparison of our result with a recent uniform convergence result derived by Freund et al. (2003) for a quantity closely related to the AUC shows that the bound provided by our result can be considerably tighter.

We consider the exact and approximate computational complexity of the multivariate LMS linear regression estimator. The LMS estimator is among the most widely used robust linear statistical estimators. Given a set of n points in ℝd and a parameter k, the problem is equivalent to computing the narrowest slab bounded by two parallel hyperplanes that contains k of the points. We present algorithms for the exact and approximate versions of the multivariate LMS problem. We also provide nearly matching lowerbounds for these problems, under the assumption that deciding whether n given points in ℝd are affinely nondegenerate requires Ω(nd) time.

In this paper, we show the existence of small coresets for the problems of computing k-median and k-means clustering for points in low dimension. In other words, we show that given a point set P in Rd, one can compute a weighted set S ⊆ P, of size O(k ε-d log n), such that one can compute the k-median/means clustering on S instead of on P, and get an (1+ε)-approximation. As a result, we improve the fastest known algorithms for (1+ε)-approximate k-means and k-median. Our algorithms have linear running time for a fixed k and ε. In addition, we can maintain the (1+ε)-approximate k-median or k-means clustering of a stream when points are being only inserted, using polylogarithmic space and update time.

We present a general technique for approximating various descriptors of the extent of a set P of n points in R d when the dimension d is an arbitrary fixed constant. For a given extent measure μ and a parameter ε > 0, it computes in time O ( n + 1/ε O (1) ) a subset Q ⊆ P of size 1/ε O (1) , with the property that (1 − ε)μ( P ) ≤ μ( Q ) ≤ μ( P ). The specific applications of our technique include ε-approximation algorithms for (i) computing diameter, width, and smallest bounding box, ball, and cylinder of P , (ii) maintaining all the previous measures for a set of moving points, and (iii) fitting spheres and cylinders through a point set P . Our algorithms are considerably simpler, and faster in many cases, than previously known algorithms.

Given a set $\mathcal{H}$ of n hyperplanes in ${\Bbb R}^d$, we present an algorithm that $\eps$-approximates the extent between the top and bottom k levels of the arrangement of $\mathcal{H}$ in time $O(n + (k/\eps)^c)$, where c is a constant depending on d. The algorithm relies on computing a subset of $\mathcal{H}$ of size $O(k/\eps^{d-1})$, in near linear time, such that the k-level of the arrangement of the subset approximates that of the original arrangement. Using this algorithm, we propose efficient approximation algorithms for shape fitting with outliers for various shapes. These are the first algorithms to handle outliers efficiently for the shape fitting problems considered.

We study the shape matching problem under the Hausdorff distance and its variants. Specifically, we consider two sets A,B of balls in Rd, d=2,3, and wish to find a translation t that minimizes the Hausdorff distance between A+t, the set of all balls in A shifted by t, and B. We consider several variants of this problem. First, we extend the notion of Hausdorff distance from sets of points to sets of balls, so that each ball has to be matched with the nearest ball in the other set. We also consider the problem in the standard setting, by computing the Hausdorff distance between the unions of the two sets (as point sets). Second, we consider either all possible translates t (as is the standard approach), or consider only translations that keep the balls of A+t disjoint from those of B. We propose several exact and approximation algorithms for these problems. Since the Hausdorff distance is sensitive to outliers, we also propose efficient approximation algorithms for computing the minimum root mean-square (rms) and the minimum summed Hausdorff distance, under translation, between two point sets in Rd. In order to obtain a fast algorithm for the summed Hausdorff distance, we propose a deterministic efficient dynamic data structure for maintaining an e-approximation of the 1-median of a set of points, under insertion and deletion.

We consider a system that allows n networked users to share control over a robotic webcamera. Each user guides the camera pan, tilt and zoom, by drawing a rectangle in the user interface. The server adjusts the camera to best satisfy the user requests, by solving a geometric optimization problem that requires fitting one rectangle to many. We improve upon previous results with an O(n3/2 log3 n) time exact algorithm for this problem. We also present a simple near-linear time e-approximation algorithm. We have implemented the latter and report on experimental results.

In this paper, we study coloring problems related to frequency assignment problems in cellular networks. In abstract setting, the problems are of the following two types:CF-coloring of regions: Given a finite family S of n regions of some fixed type (such as discs, pseudo-discs, axis-parallel rectangles, etc.), what is the minimum integer k, such that one can assign a color to each region of S, using a total of at most k colors, such that the resulting coloring has the following property: For each point p ∈b∈S b there is at least one region b∈S that contains p in its interior, whose color is unique among all regions in S that contain p in their interior (in this case we say that p is being `served' by that color). We refer to such a coloring as a conflict-free coloring of S (CF-coloring in short).CF-coloring of a range space: Given a set P of n points in Rd and a set R of ranges (for example, the set of all discs in the plane), what is the minimum integer k, such that one can color the points of P by k colors, so that for any r ∈ R with P∩r∈≠Ø, there is at least one point q ∈ P ∩ r that is assigned a unique color among all colors assigned to points of P ∩ r (in this case we say that r is 'served' by that color). We refer to such a coloring as a conflict-free coloring of (P,R) (CF-coloring in short).

Let P be a set of n points in Rd. The radius of a k-dimensional flat F with respect to P, denoted by RD(F,P), is defined to be maxp ? P dist(F,p), where dist(F,p) denotes the Euclidean distance between p and its projection onto F. The k-flat radius of P, which we denote by Rkopt(P), is the minimum, over all k-dimensional flats F, of RD(F,P). We consider the problem of computing Rkopt(P) for a given set of points P. We are interested in the high-dimensional case where d is a part of the input and not a constant. This problem is NP-hard even for k = 1. We present an algorithm that, given P and a parameter 0 < e = 1, returns a k-flat F such that RD(F,P) = (1 + e) Rkopt(P). The algorithm runs in O(nd Ce,k) time, where Ce,k is a constant that depends only on e and k. Thus the algorithm runs in time linear in the size of the point set and is a substantial improvement over previous known algorithms, whose running time is of the order of d nO(k/ec), where c is an appropriate constant.

Given a set H of n hyperplanes in IR d, we present an algorithm that ε-approximates the extent between the top and bottom k levels of the arrangement of H in time O(n+(k/ε) c), where c is a constant depending on d. The algorithm relies on computing a subset of H of size O(k/ε d−1), in near linear time, such that the k-level of the arrangement of the subset approximates that of the original arrangement. Using this algorithm, we propose efficient approximation algorithms for shape fitting with outliers for various shapes. This is the first algorithms to handle outliers efficiently for the shape fitting problems considered. 1

(MATH) In the one-round Voronoi game, the first player chooses an n-point set $\PFRST$ in a square $Q$, and then the second player places another n-point set $\PSCND$ into $Q$. The payoff for the second player is the fraction of the area of $Q$ occupied by the regions of the points of $\PSCND$ in the Voronoi diagram of $\PFRST\cup\PSCND$. We give a strategy for the second player that always guarantees him a payoff of at least $\frac12+\alpha$, for a constant $\alpha>0$ independent of n. This contrasts with the one-dimensional situation, with $Q=[0,1]$, where the first player can always win more than 1/2.

We consider the problem of cutting a set of edges on a polyhedral manifold surface, possibly with boundary, to obtain a single topological disk, minimizing either the total number of cut edges or their total length. We show that this problem is NP-hard, even for manifolds without boundary and for punctured spheres. We also describe an algorithm with running time n , where n is the combinatorial complexity, g is the genus, and k is the number of boundary components of the input surface. Finally, we describe a greedy algorithm that outputs a O(log g)-approximation of the minimum cut graph in O(g n log n) time.

(MATH) Let P be a set of n points in $\Red, and for any integer 0 ≤ k ≤ d--1, let $\RDk(P) denote the minimum over all k-flats $\FLAT$ of maxpεP Dist(p,\FLAT). We present an algorithm that computes, for any 0 < ε < 1, a k-flat that is within a distance of (1 + $egr;) \RDk(P) from each point of P. The running time of the algorithm is dnO(k/ε5log(1/ε)). The crucial step in obtaining this algorithm is a structural result that says that there is a near-optimal flat that lies in an affine subspace spanned by a small subset of points in P. The size of this "core-set" depends on k and ε but is independent of the dimension.This approach also extends to the case where we want to find a k-flat that is close to a prescribed fraction of the entire point set, and to the case where we want to find j flats, each of dimension k, that are close to the point set. No efficient approximation schemes were known for these problems in high-dimensions, when k>1 or j>1.

The constraint classification framework captures many flavors of mul- ticlass classification including winner-take-all multiclass classification, multilabel classification and ranking. We present a meta-algorithm for learning in this framework that learns via a single linear classifier in high dimension. We discuss distribution independent as well as margin-based generalization bounds and present empirical and theoretical evidence showing that constraint classification benefits over existing methods of multiclass classification.

In this paper, we show that for several clustering problems one can extract a small set of points, so that using those core-sets enable us to perform approximate clustering efficiently. The surprising property of those core-sets is that their size is independent of the dimension.Using those, we present a (1+ ε)-approximation algorithms for the k-center clustering and k-median clustering problems in Euclidean space. The running time of the new algorithms has linear or near linear dependency on the number of points and the dimension, and exponential dependency on 1/ε and k. As such, our results are a substantial improvement over what was previously known.We also present some other clustering results including (1+ ε)-approximate 1-cylinder clustering, and k-center clustering with outliers.

We present an approximation algorithm for computing the diameter of a point-set in $d$-dimensions. The new algorithm is sensitive to the “hardness” of computing the diameter of the given input, and for most inputs it is able to compute the {\em exact} diameter extremely fast. The new algorithm is simple, robust, has good empirical performance, and can be implemented quickly. As such, it seems to be the algorithm of choice in practice for computing/approximating the diameter.

Given a set of moving points in R/sup d/, we show that one can cluster them in advance, using a small number of clusters, so that at any point in time this static clustering is competitive with the optimal k-centre clustering of the point-set at this point in time. The advantage of this approach is that it avoids the usage of kinetic data structures and as such it does not need to update the clustering as time passes. To implement this static clustering efficiently, we describe a simple technique for speeding up clustering algorithms, and apply it to achieve faster clustering algorithms for several problems. In particular, we present a linear time algorithm for computing a 2-approximation to the k-centre clustering of a set of n points in R/sup d/. This is a slight improvement over the algorithm of T. Feder and D. Greene (1988), that runs in /spl Theta/(n log k) time (which is optimal in the comparison model).

For a set P of n points in R/sup d/, we define a new type of space decomposition. The new diagram provides an /spl epsi/-approximation to the distance function associated with the Voronoi diagram of P, while being of near linear size, for d/spl ges/2. This contrasts with the standard Voronoi diagram that has /spl Omega/ (n/sup [d/2]/) complexity in the worst case.

Shape fitting is a fundamental optimization problem in computer science. The authors present a general and unified technique for solving a certain family of such problems. Given a point set P in R/sup d/, this technique can be used to /spl epsi/-approximate: (i) the min-width annulus and shell that contains P, (ii) minimum width cylindrical shell containing P, (iii) diameter, width, minimum volume bounding box of P, and (iv) all the previous measures for the case the points are moving. The running time of the resulting algorithms is O(n + 1//spl epsi//sup c/), where c is a constant that depends on the problem at hand. Our new general technique enables us to solve those problems without resorting to a careful and painful case by case analysis, as was previously done for those problems. Furthermore, for several of those problems our results are considerably simpler and faster than what was previously known. In particular, for the minimum width cylindrical shell problem, our solution is the first algorithm whose running time is subquadratic in n. (In fact we get running time linear in n.).

We suggest a new simple forwarding technique to speed up IP destination address lookup. The technique is a natural extension of IP, requires 5 bits in the IP header (IPv4, 7 in IPv6), and performs IP lookup nearly as fast as IP/Tag switching but with a smaller memory requirement and a much simpler protocol. The basic idea is that each router adds a "clue" to each packet, telling its downstream router where it ended the IP lookup. Since the forwarding tables of neighboring routers are similar, the clue either directly determines the best prefix match for the downstream router, or provides the downstream router with a good point to start its IP lookup. The new scheme thus prevents repeated computations and distributes the lookup process across the routers along the packet path. Each router starts the lookup computation at the point its upstream neighbor has finished. Furthermore, the new scheme is easily assimilated into heterogeneous IP networks, does not require routers coordination, and requires no setup time. Even a flow of one packet enjoys the benefits of the scheme without any additional overhead. The speedup we achieve is about 10 times faster than current standard techniques. In a sense, this paper shows that the current routers employed in the Internet are clue-less; namely, it is possible to speed up the IP lookup by an order of magnitude without any major changes to the existing protocols.

The algorithms for computing a shortest path on a polyhedral surface are slow, complicated, and numerically unstable.We have developed and implemented a robust and efficient algorithm for computing approximate shortest paths on a convex polyhedral surface.Given a convex polyhedral surface P in R 3 , two points s, t E P, and a parameter e > 0, it computes a path between s and t on P whose length is at most (1 + c) times the length of the shortest path between those points.It first constructs in time O(n/v~ ) a graph of size O(1/s4), computes a shortest path on this graph, and projects the path onto the surface in O(n/c) time, where n is the number of vertices of P. In the post-processing we have added a heuristic that considerably improves the quality of the resulting path.

In this paper, we present an (1 + ¢)-approximation algorithm to the minimum-spanning tree of points in a planar arrangement of lines, where the metric is the number of crossings between the spanning tree and the lines.The expected running time is O ((n/e5)a 3 (n) log 5 n), where c > 0 is a prescribed constant.In the second part of our paper, we show how to embed such a crossing metric of hyperplanes in d-dimensions, in subquadratic time, into high-dimensions, so that the distances are preserved.As a result, we can deploy a large collection of subquadratic approximations algorithms [IM98, GIV99] for problems involving points with the crossing metric as a distance function.Applications include MST, matching, clustering, nearestneighbor, and furthest-neighbor.

We present several variants of a new randomized incremental algorithm for computing a cutting in an arrangement of n lines in the plane. The algorithms produce cuttings whose expected size is O(r 2 ), and the expected running time of the algorithms is O(nr). Both bounds are asymptotically optimal for nondegenerate arrangements. The algorithms are also simple to implement, and we present empirical results showing that they perform well in practice. We also present another efficient algorithm (with slightly worse time bound) that generates small cuttings whose size is guaranteed to be close to the best known upper bound of J. Matou{s}ek [Discrete Comput. Geom., 20 (1998), pp. 427--448].

We present a randomized algorithm for computing portions of an arrangement of n arcs in the plane, each pair of which intersect in at most t points. We use this algorithm to perform online walks inside such an arrangement (i.e., compute all the faces that a curve, given in an online manner, crosses) and to compute a level in an arrangement, both in an output-sensitive manner. The expected running time of the algorithm is $O(\lambda_{t+2}(m+n)\log n)$, where m is the number of intersections between the walk and the given arcs. No similarly efficient algorithm is known for the general case of arcs. For the case of lines and for certain restricted cases involving line segments, our algorithm improves the best known algorithm of [M. H. Overmars and J. van Leeuwen, J. Comput. System Sci., 23 (1981), pp. 166--204] by almost a logarithmic factor.

Let S be a set of n points in R d . The "roundness" of S can be measured by computing the width ! = ! (S) of the thinnest spherical shell (or annulus in R 2 ) that contains S. This paper contains three main results related to computing ! : (i) For d = 2, we can compute in O(n log n) time an annulus containing S whose width is at most 2! (S). We extend this algorithm, so that for any given parameter " ? 0, an annulus containing S whose width is at most (1 + ")! , is computed in time O(n log n + n=" 2 ). (ii) For d 3, given a parameter " ? 0, we can compute a shell containing S of width at most (1+ ")! either in time O \\Gamma n " d log( \\Delta ! " ) \\Delta or in time O \\Gamma n " d\\Gamma2 \\Gamma log n + 1 " \\Delta log \\Gamma \\Delta ! " \\Delta\\Delta . Work by P.A. was supported by Army Research Office MURI grant DAAH04-96-1-0013, by a Sloan fellowship, by NSF grants EIA--9870724, and CCR--9732787, by an NYI award, and by a grant from ...

We present a randomized algorithm for computing portions of an arrangement of n arcs in the plane, each pair of which intersect in at most t points. We use this algorithm to perform online walks inside such an arrangement (i.e., compute all the faces that a curve, given in an online manner, crosses), and to compute a level in an arrangement, both in an output-sensitive manner. The expected running time of the algorithm is O(/spl lambda//sub t+2/(m+n) log n), where m is the number of intersections between the walk and the given arcs. No similarly efficient algorithm is known for the general case of arcs. For the case of lines and for certain restricted cases involving line segments, our algorithm improves the best known algorithm of (Overmars and van Leeuwen, 1981) by almost a logarithmic factor.

We suggest a new simple forwarding technique to speed-up IP destination address lookup. The technique is a natural extension of IP, requires 5 bits in the IP header (IPv4, 7 in IPv6) and performs IP lookup nearly as fast as IP/Tag-switching but with a smaller memory requirement and a much simpler protocol. The basic idea is that each router adds a "clue" to each packet, telling its downstream router where it ended the IP lookup. Since the forwarding tables of neighboring routers are similar, the clue either directly determines the best prefix match for the downstream router, or provides the downstream router with a good point to start its IP lookup. The new scheme thus prevents repeated computations and distributes the lookup process across the routers along the packet path. Each router starts the lookup computation at the point its up-stream neighbor has finished. Furthermore, the new scheme is easily assimilated into heterogeneous IP networks, does not require routers coordination, and requires no setup time. Even a flow of one packet enjoys the benefits of the scheme without any additional overhead. The speedup we achieve is about 10 times faster than current standard techniques. In a sense this paper shows that the current routers employed in the Internet are clue-less; Namely, it is possible to speedup the IP-lookup by an order of magnitude without any major changes to the existing protocols.

We present a new technique for constructing a data structure that approximates shortest path maps in $\Re^d$. By applying this technique, we get the following two results on approximate shortest path maps in $\Re^3$. (i) Given a polyhedral surface or a convex polytope $\P$ with n edges in $\Re^3$, a source point s on $\P$, and a real parameter $0 < \eps \leq 1$, we present an algorithm that computes a subdivision of $\P$ of size $O((n/\eps) \log( 1/\eps ))$ which can be used to answer efficiently approximate shortest path queries. Namely, given any point t on $\P$, one can compute, in $O(\log{(n/\eps)})$ time, a distance $\Delta_{\P,s}(t)$, such that $d_{\P,s}(t) \leq \Delta_{\P,s}(t) \leq (1 + \eps)d_{\P,s}(t)$, where $d_{\P,s}(t)$ is the length of a shortest path between s and t on $\P$. The map can be computed in $O(n^2 \log{n} + (n/\eps) \log{(1/\eps)} \log{(n/\eps)})$ time, for the case of a polyhedral surface, and in $O((n/\eps^3) \log ( 1/\eps ) + (n/\eps^{1.5}) \log{(1/\eps)} \log{n})$ time if $\P$ is a convex polytope. (ii) Given a set of polyhedral obstacles $\O$ with a total of n edges in $\Re^3$, a source point {\it s} in $\Re^3 {\rm \setminus \inter} \cup\scriptstyle{_{O \in \O}} O$, and a real parameter $0 < \eps \leq 1$, we present an algorithm that computes a subdivision of $\Re^3$, which can be used to answer efficiently approximate shortest path queries. That is, for any point $t \in \Re^3$, one can compute, in $O(\log{(n/\eps)})$ time, a distance $\Delta_{\O,s}(t)$ that $\eps$-approximates the length of a shortest path from {\it s} to {\it t} that avoids the interiors of the obstacles. This subdivision can be computed in roughly $O(n^4/\eps^6)$ time.

Let P be a set of n. points in IRd in general position, i.e., no i + 1 points on a common (i -1)-flat, 1 < i 5 d.A k-set @'P is a set S of E points in P that can be separated from P \ S by a hyperplane.A j-facet of P is an oriented (d -l)simplex spanned by d points in P which has exactly j points from P on the positive side of its affine hull.If P is a planar point set and n is even, a halving edge is an undirected edge between two points, such that the connecting line has the same number of points on either side.The number of (n/2)-sets is twice the number of halving edges.Inspired by Dey's recent proof of a new bound on the number of k-sets we show that where degp is the number of halving edges incident to point p and C is the number of crossing pairs of halving edges.The identity allows us, among other things, to determine the masimum number of halving edges in a set of 12 points.An anaIogous identity holds for j-facets.For P in IR3 we show that for j 5 n/4 -2 the number of cs j)-facets (i.e., i-facets with 0 5 i 5 j) is maximized for sets in convex position, where this number is known to be (j + l)(j + 2)n -2(j + l)(j + 2)(j + 3)/3.For 1; 5 n/4 -1, k2n -k(k -1)(2A + 5)/3 is the tight upper bound for the number of (5 A)-sets (i.e., i-sets with 1 ': i 5 k).'h't of this work %S Performed while R.S. and E.W. were visiting the DlhfAa center in November 1989.while R.S. visited FU Berlin in 1992, while E.W. visited

Article Free Access Share on Fly cheaply: on the minimum fuel-consumption problem Authors: Alon Efrat School of Mathematical Sciences, Tel-Aviv University, Tel-Aviv 69982, Israel School of Mathematical Sciences, Tel-Aviv University, Tel-Aviv 69982, IsraelView Profile , Sariel Har-Peled School of Mathematical Sciences, Tel-Aviv University, Tel-Aviv 69982, Israel School of Mathematical Sciences, Tel-Aviv University, Tel-Aviv 69982, IsraelView Profile Authors Info & Claims SCG '98: Proceedings of the fourteenth annual symposium on Computational geometryJune 1998 Pages 143–145https://doi.org/10.1145/276884.276900Online:07 June 1998Publication History 3citation209DownloadsMetricsTotal Citations3Total Downloads209Last 12 Months3Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF

We present a new randomized incremental algorithm for computing a cutting in an arrangement of lines in the plane.The nlgorithm produce cuttings whose expected size is 0 P"), and the expected running time of the algorithm is 0 I r-w).Both bounds are asymptotically optimal for nondegenerate arrangements.The algorithm is also simple to implement, and we present empirical results showing that the algorithm and some of its variants perform well in practice.We alao present another efficient algorithm (with slightly worse time bound) that generates small cuttings whose size is guaranteed to be close to the known upper bound of [9].

Given a convex body C in the plane, its discrete hull is Co s ConvexHull(C I-I C), where C = Z x Z is the integer lattice.We present an O(lC"l logC(C))-time algorithm for calculating the discrete hull of C, where IC"l denote5 the number of vertices of Co, and a(C) is the diameter of C. Actually, using known combinatorial bounds, the running time of the algorithm is 0(6(C)als log J(C)).In particular, this bound applies when C is a disk.

We present a new technique for constructing a data-structure that approximates shortest path maps in lH'.By applying tbia technique, we get the following two results on approxi-

Given a convex polytope P with n edges in \(\Bbb R\)3 , we present a relatively simple algorithm that preprocesses P in O(n) time, such that, given any two points \(s,t \in \partial P\) , and a parameter 0 < \(\varepsilon \le\) 1, it computes, in O(log n) /ɛ1.5 + 1/ ɛ3 ) time, a distance ΔP(s,t) , such that dP(s,t)\(\leq\)ΔP(s,t)\(\leq\) (1+ɛ )dP(s,t) , where dP(s,t) is the length of the shortest path between s and t on \(\partial{P}\) . The algorithm also produces a polygonal path with O (1/ɛ1.5 ) segments that avoids the interior of P and has length ΔP(s,t) .

Given a convex polytope P with n faces in ℝ 3 , points ∈ ∂P, and a parameter 0 < ϵ ≤ 1, we present an algorithm that constructs a path on ∂P from s to t whose length is at most (1 + ϵ) d p (s, t) , where d p (s, t) is the length of the shortest path between s and t on ∂P. The algorithm runs in O(n log 1/ϵ + 1/ϵ 3 ) time, and is relatively simple. The running time is O(n + 1/ϵ 3 ) if we only want the approximate shortest path distance and not the path itself. We also present an extension of the algorithm that computes approximate shortest path distances from a given source point on ∂P to all vertices of P .

We present an approximation algorithm that, given a convex polytope P with n faces in lR3, points s, t c 8P, and a parameter O < & <1, constructs a path on t3P from s to t whose length is at most (1 +E)dP(S, t), where dp (s, t) is the length of the shortest path between s and t on 8P.The algorithm runs intime. and is relatively simple to implement.We also present an extension of the algorithm that computes approximate shortest paths from a given source point on 8P to all vertices of P.