We give a deterministic algorithm for triangulating a simple polygon in linear time. The basic strategy is to build a coarse approximation of a triangulation in a bottom-up phase and then use the information computed along the way to refine the triangulation in a top-down phase. The main tools used are the polygon-cutting theorem, which provides us with a balancing scheme, and the planar separator theorem, whose role is essential in the discovery of new diagonals. Only elementary data structures are required by the algorithm. In particular, no dynamic search trees, of our algorithm.

Triangulating a simple polygon in linear time

We initiate the study of graph sketching, ie, algorithms that use a limited number of linear measurements of a graph to determine the properties of the graph While a graph on n nodes is essentially O(n2)-dimensional, we show the existence of a distribution over random projections into d-dimensional "sketch" space (d

/pdf/analyzing-graph-structure-via-linear-measurements-s086u09xf0.pdf

Analyzing graph structure via linear measurements

We consider the point-to-point (approximate) shortest-path query problem, which is the following generalization of the classical single-source (SSSP) and all-pairs shortest-path (APSP) problems: we are first presented with a network (graph). A so-called preprocessing algorithm may compute certain information (a data structure or index) to prepare for the next phase. After this preprocessing step, applications may ask shortest-path or distance queries, which should be answered as fast as possible.Due to its many applications in areas such as transportation, networking, and social science, this problem has been considered by researchers from various communities (sometimes under different names): algorithm engineers construct fast route planning methods; database and information systems researchers investigate materialization tradeoffs, query processing on spatial networks, and reachability queries; and theoretical computer scientists analyze distance oracles and sparse spanners. Related problems are considered for compact routing and distance labeling schemes in networking and distributed computing and for metric embeddings in geometry as well.In this survey, we review selected approaches, algorithms, and results on shortest-path queries from these fields, with the main focus lying on the tradeoff between the index size and the query time. We survey methods for general graphs as well as specialized methods for restricted graph classes, in particular for those classes with arguable practical significance such as planar graphs and complex networks.

/pdf/shortest-path-queries-in-static-networks-t3dlcej7at.pdf

Shortest-path queries in static networks

Consider the following Online Boolean Matrix-Vector Multiplication problem: We are given an n x n matrix M and will receive n column-vectors of size n, denoted by v1, ..., vn, one by one. After seeing each vector vi, we have to output the product Mvi before we can see the next vector. A naive algorithm can solve this problem using O(n3) time in total, and its running time can be slightly improved to O(n3/log2 n) [Williams SODA'07]. We show that a conjecture that there is no truly subcubic (O(n3-e)) time algorithm for this problem can be used to exhibit the underlying polynomial time hardness shared by many dynamic problems. For a number of problems, such as subgraph connectivity, Pagh's problem, d-failure connectivity, decremental single-source shortest paths, and decremental transitive closure, this conjecture implies tight hardness results. Thus, proving or disproving this conjecture will be very interesting as it will either imply several tight unconditional lower bounds or break through a common barrier that blocks progress with these problems. This conjecture might also be considered as strong evidence against any further improvement for these problems since refuting it will imply a major breakthrough for combinatorial Boolean matrix multiplication and other long-standing problems if the term "combinatorial algorithms" is interpreted as "Strassen-like algorithms" [Ballard et al. SPAA'11].The conjecture also leads to hardness results for problems that were previously based on diverse problems and conjectures -- such as 3SUM, combinatorial Boolean matrix multiplication, triangle detection, and multiphase -- thus providing a uniform way to prove polynomial hardness results for dynamic algorithms; some of the new proofs are also simpler or even become trivial. The conjecture also leads to stronger and new, non-trivial, hardness results, e.g., for the fully-dynamic densest subgraph and diameter problems.

/pdf/unifying-and-strengthening-hardness-for-dynamic-problems-via-8z0ox0kv50.pdf

Unifying and Strengthening Hardness for Dynamic Problems via the Online Matrix-Vector Multiplication Conjecture

We present a number of new results on one of the most extensively studied topics in computational geometry, orthogonal range searching All our results are in the standard word RAM model: We present two data structures for 2-d orthogonal range emptiness The first achieves O(n lg lg n) space and O(lg lg n) query time, assuming that the n given points are in rank space This improves the previous results by Alstrup, Brodal, and Rauhe (FOCS'00), with O(n lge n) space and O(lg lg n) query time, or with O(n lg lg n) space and O(lg2lg n) query time Our second data structure uses O(n) space and answers queries in O(lge n) time The best previous O(n)-space data structure, due to Nekrich (WADS'07), answers queries in O(lg n/lg lg n) time We give a data structure for 3-d orthogonal range reporting with O(n lg1+e n) space and O(lg lg n + k) query time for points in rank space, for any constant e>0 This improves the previous results by Afshani (ESA'08), Karpinski and Nekrich (COCOON'09), and Chan (SODA'11), with O(n lg3 n) space and O(lg lg n + k) query time, or with O(n lg1+en) space and O(lg2lg n + k) query time Consequently, we obtain improved upper bounds for orthogonal range reporting in all constant dimensions above 3Our approach also leads to a new data structure for 2D orthogonal range minimum queries with O(n lge n) space and O(lg lg n) query time for points in rank space We give a randomized algorithm for 4-d offline dominance range reporting/emptiness with running time O(n log n) plus the output size This resolves two open problems (both appeared in Preparata and Shamos' seminal book): given a set of n axis-aligned rectangles in the plane, we can report all k enclosure pairs (ie, pairs (r1,r2) where rectangle r1 completely encloses rectangle r2) in O(n lg n + k) expected time; given a set of n points in 4-d, we can find all maximal points (points not dominated by any other points) in O(n lg n) expected time The most recent previous development on (a) was reported back in SoCG'95 by Gupta, Janardan, Smid, and Dasgupta, whose main result was an O([n lg n + k] lg lg n) algorithm The best previous result on (b) was an O(n lg n lg lg n) algorithm due to Gabow, Bentley, and Tarjan---from STOC'84! As a consequence, we also obtain the current-record time bound for the maxima problem in all constant dimensions above~4

/pdf/orthogonal-range-searching-on-the-ram-revisited-1dyqz2ey73.pdf

Orthogonal range searching on the RAM, revisited

We show that a large fraction of the data-structure lower bounds known today in fact follow by reduction from the communication complexity of lopsided (asymmetric) set disjointness. This includes lower bounds for (i) high-dimensional problems, where the goal is to show large space lower bounds; (ii) constant-dimensional geometric problems, where the goal is to bound the query time for space $O(n\cdot\mathrm{polylog}n)$; and (iii) dynamic problems, where we are looking for a trade-off between query and update time. (In the last case, our bounds are slightly weaker than the originals, losing a $\lg\lg n$ factor.) Our reductions also imply the following new results: (i) an $\Omega(\lg n/\lg\lg n)$ bound for four-dimensional range reporting, given space $O(n\cdot\mathrm{polylog}n)$ (this is quite timely, since a recent result [Y. Nekrich, in Proceedings of the 23rd ACM Symposium on Computational Geometry (SoCG), 2007, pp. 344-353] solved three-dimensional reporting in $O(\lg^2\lg n)$ time, raising the prospect that higher dimensions could also be easy); (ii) a tight space lower bound for the partial match problem, for constant query time; and (iii) the first lower bound for reachability oracles. In the process, we prove optimal randomized lower bounds for lopsided set disjointness.

Unifying the Landscape of Cell-Probe Lower Bounds

We present an $O(\lg \lg n)$-competitive online binary search tree, improving upon the best previous (trivial) competitive ratio of $O(\lg n)$. This is the first major progress on Sleator and Tarjan’s dynamic optimality conjecture of 1985 that $O(1)$-competitive binary search trees exist.

/pdf/dynamic-optimality-almost-30s88gr3nh.pdf

Dynamic Optimality—Almost

Given a planar subdivision whose coordinates are integers bounded by $U\leq2^w$, we present a linear-space data structure that can answer point-location queries in $O(\min\{\lg n/\lg\lg n,$ $\sqrt{\lg U/\lg\lg U}\})$ time on the unit-cost random access machine (RAM) with word size $w$. This is the first result to beat the standard $\Theta(\lg n)$ bound for infinite precision models. As a consequence, we obtain the first $o(n\lg n)$ (randomized) algorithms for many fundamental problems in computational geometry for arbitrary integer input on the word RAM, including: constructing the convex hull of a three-dimensional (3D) point set, computing the Voronoi diagram or the Euclidean minimum spanning tree of a planar point set, triangulating a polygon with holes, and finding intersections among a set of line segments. Higher-dimensional extensions and applications are also discussed. Though computational geometry with bounded precision input has been investigated for a long time, improvements have been limited largely to problems of an orthogonal flavor. Our results surpass this long-standing limitation, answering, for example, a question of Willard (SODA'92).

/pdf/transdichotomous-results-in-computational-geometry-i-point-4xogmqv98y.pdf

Transdichotomous Results in Computational Geometry, I: Point Location in Sublogarithmic Time

We convert cell-probe lower bounds for polynomial space into stronger lower bounds for near-linear space. Our technique applies to any lower bound proved through the richness method. For example, it applies to partial match and to near-neighbor problems, either for randomized exact search or for deterministic approximate search (which are thought to exhibit the curse of dimensionality). These problems are motivated by searching in large databases, so near-linear space is the most relevant regime. Typically, richness has been used to imply $\Omega(d/\lg n)$ lower bounds for polynomial-space data structures, where $d$ is the number of bits of a query. This is the highest lower bound provable through the classic reduction to communication complexity. However, for space $n\lg^{O(1)}n$, we now obtain bounds of $\Omega(d/\lg d)$. This is a significant improvement for natural values of $d$, such as $\lg^{O(1)}n$. In the most important case of $d=\Theta(\lg n)$, we have the first superconstant lower bound. From a complexity-theoretic perspective, our lower bounds are the highest known for any static data structure problem, significantly improving on previous records.

/pdf/higher-lower-bounds-for-near-neighbor-and-further-rich-3s8wtpjcbs.pdf

Higher Lower Bounds for Near-Neighbor and Further Rich Problems

Dynamic connectivity is a well-studied problem, but so far the most compelling progress has been confined to the edge-update model: maintain an understanding of connectivity in an undirected graph, subject to edge insertions and deletions. In this paper, we study two more challenging, yet equally fundamental, problems. Subgraph connectivity asks us to maintain an understanding of connectivity under vertex updates: updates can turn vertices on and off, and queries refer to the subgraph induced by on vertices. (For instance, this is closer to applications in networks of routers, where node faults may occur.) We describe a data structure supporting vertex updates in $\widetilde{O}(m^{2/3})$ amortized time, where $m$ denotes the number of edges in the graph. This greatly improves upon the previous result [T. M. Chan, in Proceedings of the 34th Annual ACM Symposium on Theory of Computing (STOC), 2002, pp. 7-13], which required fast matrix multiplication and had an update time of $O(m^{0.94})$. The new data structure is also simpler. Geometric connectivity asks us to maintain a dynamic set of $n$ geometric objects and query connectivity in their intersection graph. (For instance, the intersection graph of balls describes connectivity in a network of sensors with bounded transmission radius.) Previously, nontrivial fully dynamic results were known only for special cases like axis-parallel line segments and rectangles. We provide similarly improved update times, $\widetilde{O}(n^{2/3})$, for these special cases. Moreover, we show how to obtain sublinear update bounds for virtually all families of geometric objects which allow sublinear time range queries. In particular, we obtain the first sublinear update time for arbitrary two-dimensional line segments: $O^*(n^{9/10})$; for $d$-dimensional simplices: $O^*(n^{1-\frac{1}{d(2d+1)}})$; and for $d$-dimensional balls: $O^*(n^{1-\frac{1}{(d+1)(2d+3)}})$.

Mihai Pa caron

Papers

Unifying the Landscape of Cell-Probe Lower Bounds

Dynamic Optimality—Almost

Transdichotomous Results in Computational Geometry, I: Point Location in Sublogarithmic Time

Higher Lower Bounds for Near-Neighbor and Further Rich Problems

Dynamic Connectivity: Connecting to Networks and Geometry