Searcharxiv⌕ Search

arXiv subjects

Sariel Har-Peled

Publications and source records attributed to Sariel Har-Peled.

At least 73 records · Page 4Linked to original sources
arXiv2021

Stabbing Pairwise Intersecting Disks by Five Points

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

cs.CG↗
arXiv2021

Active Learning a Convex Body in Low Dimensions

Consider a set $P \subseteq \Re^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 $O( h(P) \log n)$ queries, where $h(P)$ is the largest subset of points of $P$ in convex position. Furthermore, we show that in two dimensions one can solve this problem using $O( v(P,C) \log^2 n )$ oracle queries, where $v(P, C)$ is a lower bound on the minimum number of queries that any algorithm for this specific instance requires.

cs.CG↗
arXiv2021

Shortest Secure Path in a Voronoi Diagram

We investigate the problem of computing the shortest secure path in a Voronoi diagram. Here, a path is secure if it is a sequence of touching Voronoi cells, where each Voronoi cell in the path has a uniform cost of being secured. Importantly, we allow inserting new sites, which in some cases leads to significantly shorter paths. We present an $O(n \log n)$ time algorithm for solving this problem in the plane, which uses a dynamic additive weighted Voronoi diagram to compute this path. The algorithm is an interesting combination of the continuous and discrete Dijkstra algorithms. We also implemented the algorithm using CGAL.

cs.CG↗
arXiv2021

Sampling a Near Neighbor in High Dimensions -- Who is the Fairest of Them All?

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 inherent unfairness of NN data structures and shows the performance of our algorithms on real-world datasets.

cs.DS↗
arXiv2020

Some Geometric Applications of Anti-Chains

We present an algorithmic framework for computing anti-chains of maximum size in geometric posets. Specifically, posets in which the entities are geometric objects, where comparability of two entities is implicitly defined but can be efficiently tested. Computing the largest anti-chain in a poset can be done in polynomial time via maximum-matching in a bipartite graph, and this leads to several efficient algorithms for the following problems, each running in (roughly) $O(n^{3/2})$ time: (A) Computing the largest Pareto-optimal subset of a set of $n$ points in $\mathbb{R}^d$. (B) Given a set of disks in the plane, computing the largest subset of disks such that no disk contains another. This is quite surprising, as the independent version of this problem is computationally hard. (C) Given a set of axis-aligned rectangles, computing the largest subset of non-crossing rectangles.

cs.CG↗
arXiv2020

A Spanner for the Day After

We show how to construct $(1+\varepsilon)$-spanner over a set $P$ of $n$ points in $\mathbb{R}^d$ that is resilient to a catastrophic failure of nodes. Specifically, for prescribed parameters $\vartheta,\varepsilon \in (0,1)$, the computed spanner $G$ has $ O\bigl(\varepsilon^{-c} \vartheta^{-6} n \log n (\log\log n)^6 \bigr) $ edges, where $c= O(d)$. Furthermore, for any $k$, and any deleted set $B \subseteq P$ of $k$ points, the residual graph $G \setminus B$ is $(1+\varepsilon)$-spanner for all the points of $P$ except for $(1+\vartheta)k$ of them. No previous constructions, beyond the trivial clique with $O(n^2)$ edges, were known such that only a tiny additional fraction (i.e., $\vartheta$) 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.

cs.CG↗
arXiv2020

On Locality-Sensitive Orderings and their Applications

For any constant $d$ and parameter $\varepsilon > 0$, we show the existence of (roughly) $1/\varepsilon^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 $\varepsilon\| p - q \|$ from $p$ or $q$. These orderings are extensions of the $\mathcal{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.

cs.CG↗
arXiv2020

Submodular Clustering in Low Dimensions

We study a clustering problem where the goal is to maximize the coverage of the input points by $k$ chosen centers. Specifically, given a set of $n$ points $P \subseteq \mathbb{R}^d$, the goal is to pick $k$ centers $C \subseteq \mathbb{R}^d$ that maximize the service $ \sum_{p \in P}\mathsfφ\bigl( \mathsf{d}(p,C) \bigr) $ to the points $P$, where $\mathsf{d}(p,C)$ is the distance of $p$ to its nearest center in $C$, and $\mathsfφ$ is a non-increasing service function $\mathsfφ : \mathbb{R}^+ \to \mathbb{R}^+$. This includes problems of placing $k$ base stations as to maximize the total bandwidth to the clients -- indeed, the closer the client is to its nearest base station, the more data it can send/receive, and the target is to place $k$ base stations so that the total bandwidth is maximized. We provide an $n^{\varepsilon^{-O(d)}}$ time algorithm for this problem that achieves a $(1-\varepsilon)$-approximation. Notably, the runtime does not depend on the parameter $k$ and it works for an arbitrary non-increasing service function $\mathsfφ : \mathbb{R}^+ \to \mathbb{R}^+$.

cs.CG↗
arXiv2020

Edge Estimation with Independent Set Oracles

We study the task of estimating the number of edges in a graph with access to only 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) $\mathrm{polylog}(n)$ bipartite independent set queries, or (ii) ${n}^{2/3} \cdot\mathrm{polylog}(n)$ independent set queries.

cs.DS↗
arXiv2020

The Maximum-Level Vertex in an Arrangement of Lines

Let $L$ be a set of $n$ lines in the plane, not necessarily in general position. We present an efficient algorithm for finding all the vertices of the arrangement $A(L)$ of maximum level, where the level of a vertex $v$ is the number of lines of $L$ that pass strictly below $v$. The problem, posed in Exercise~8.13 in de Berg etal [BCKO08], appears to be much harder than it seems, as this vertex might not be on the upper envelope of the lines. We first assume that all the lines of $L$ are distinct, and distinguish between two cases, depending on whether or not the upper envelope of $L$ contains a bounded edge. In the former case, we show that the number of lines of $L$ that pass above any maximum level vertex $v_0$ is only $O(\log n)$. In the latter case, we establish a similar property that holds after we remove some of the lines that are incident to the single vertex of the upper envelope. We present algorithms that run, in both cases, in optimal $O(n\log n)$ time. We then consider the case where the lines of $L$ are not necessarily distinct. This setup is more challenging, and the best we have is an algorithm that computes all the maximum-level vertices in time $O(n^{4/3}\log^{3}n)$. Finally, we consider a related combinatorial question for degenerate arrangements, where many lines may intersect in a single point, but all the lines are distinct: We bound the complexity of the weighted $k$-level in such an arrangement, where the weight of a vertex is the number of lines that pass through the vertex. We show that the bound in this case is $O(n^{4/3})$, which matches the corresponding bound for non-degenerate arrangements, and we use this bound in the analysis of one of our algorithms.

cs.CG↗
arXiv2019

Covering Polygons by Min-Area Convex Polygons

Given a set of disjoint simple polygons $σ_1, \ldots, σ_n$, of total complexity $N$, consider a convexification process that repeatedly replaces a polygon by its convex hull, and any two (by now convex) polygons that intersect by their common convex hull. This process continues until no pair of polygons intersect. We show that this process has a unique output, which is a cover of the input polygons by a set of disjoint convex polygons, of total minimum area. Furthermore, we present a near linear time algorithm for computing this partition. The more general problem of covering a set of $N$ segments (not necessarily disjoint) by min-area disjoint convex polygons can also be computed in near linear time. A similar result is already known, see the work by Barba et al. [BBB+13].

cs.CG↗
arXiv2019

Near Neighbor: Who is the Fairest of Them All?

$\newcommand{\ball}{\mathbb{B}}\newcommand{\dsQ}{\mathcal{Q}}\newcommand{\dsS}{\mathcal{S}}$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., $\ball(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 in the $r$-neighborhood of a query $q$ with almost uniform probability. The query time is proportional to $O\bigl( \mathrm{dns}(q.r) \dsQ(n,c) \bigr)$, and its space is $O(\dsS(n,c))$, where $\dsQ(n,c)$ and $\dsS(n,c)$ are the query time and space of an LSH algorithm for $c$-approximate near neighbor, and $\mathrm{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.

cs.LG↗
arXiv2019

Smallest k-Enclosing Rectangle Revisited

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 etal [KRS17]. 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+\varepsilon)$-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.

cs.CG↗
arXiv2019

Journey to the Center of the Point Set

$\renewcommand{\Re}{\mathbb{R}} \newcommand{\eps}{\varepsilon} \newcommand{\Net}{S} \newcommand{\tldO}{\widetilde{O}} \newcommand{\body}{C} $ We revisit an algorithm of Clarkson etal [CEMST96], that computes (roughly) a $1/(4d^2)$-centerpoint in $\tldO(d^9)$ time, for a point set in $\Re^d$, where $\tldO$ hides polylogarithmic terms. We present an improved algorithm that computes (roughly) a $1/d^2$-centerpoint with running time $\tldO(d^7)$. While the improvements are (arguably) mild, it is the first progress on this well known problem in over twenty 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.

cs.CG↗
arXiv2018

Coresets for $k$-Means and $k$-Median Clustering and their Applications

$\renewcommand{\Re}{{\rm I\!\hspace{-0.025em} R}} \newcommand{\eps}{\varepsilon} \newcommand{\Coreset}{\mathcal{S}} $ 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 $\Re^d$, one can compute a weighted set $\Coreset \subseteq P$, of size $O(k \eps^{-d} \log{n})$, such that one can compute the $k$-median/means clustering on $\Coreset$ instead of on $P$, and get an $(1+\eps)$-approximation. As a result, we improve the fastest known algorithms for $(1+\eps)$-approximate $k$-means and $k$-median clustering. Our algorithms have linear running time for a fixed $k$ and $\eps$. In addition, we can maintain the $(1+\eps)$-approximate $k$-median or $k$-means clustering of a stream when points are being only inserted, using polylogarithmic space and update time.

cs.CG↗
arXiv2018

Two (Known) Results About Graphs with No Short Odd Cycles

Consider a graph with $n$ vertices where the shortest odd cycle is of length $>2k+1$. We revisit two known results about such graphs: (I) Such a graph is almost bipartite, in the sense that it can be made bipartite by removing from it $O\bigl( (n/k) \log (n/k) \bigr)$ vertices. While this result is known [GKL97] -- our new proof seems to yield slightly better constants, and is (arguably) conceptually simpler. To this end, we state (and prove) a version of CKR partitions [CKR01, FRT04] that has a small vertex separator, and it might be of independent interest. While this must be known in the literature, we were unable to find a reference to it, and it is included for the sake of completeness. (II) While such graphs can be quite dense (e.g., consider a the bipartite clique, which has no odd cycles), they have a large independent set. Specifically, we prove that such graphs have independent sets of size $\geq \bigl(1-o(1)\bigr)n^{k/(k+1)}$. Again, this result is known and is implied by the work of Shearer [She95], but our proof is simpler and (seems to) yield a better constant.

cs.DM↗
arXiv2018

Approximate Sparse Linear Regression

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.

cs.CG↗