Algorithms for Unit-Disk Graphs and Related Problems

In this dissertation, we study algorithms for several problems on unit-disk graphs and related problems. The unit-disk graph can be viewed as an intersection graph of a set of congruent disks. Unit-disk graphs have been extensively studied due to many of their applications, e.g., modeling the topology of wireless sensor networks. Lots of problems on unit-disk graphs have been considered in the literature, such as shortest paths, clique, independent set, distance oracle, diameter, etc. Specifically, we study the following problems in this dissertation: L1 shortest paths in unit-disk graphs, reverse shortest paths in unit-disk graphs, minimum bottleneck moving spanning tree, unit-disk range reporting, distance selection, etc. We develop efficient algorithms for these problems and our results are either first-known solutions or somehow improve the previous work. Given a set P of n points in the plane and a parameter r \u3e 0, a unit-disk graph G(P) can be defined using P as its vertex set and two points of P are connected by an edge if the distance between these two points is at most r. The weight of an edge is one in the unweighted case and is equal to the distance between the two endpoints in the weighted case. Note that the distance between two points can be measured by different metrics, e.g., L1 or L2 metric. In the first problem of L1 shortest paths in unit-disk graphs, we are given a point set P and a source point s ∈ P, the problem is to find all shortest paths from s to all other vertices in the L1 weighted unit-disk graph defined on set P. We present an O(n log n) time algorithm, which matches the Ω(n log n)-time lower bound. In the second problem, we are given a set P of n points, parameters r, λ \u3e 0, and two points s and t of P, the goal is to compute the smallest r such that the shortest path length between s and t in the unit-disk graph with respect to set P and parameter r is at most λ. This problem can be defined in both unweighted and weighted cases. We propose an algorithm of O(⌊λ⌋ · n log n) time and another algorithm of O(n5/4 log7/4 n) time for the unweighted case. We also given an O(n5/4 log5/2 n) time algorithm for the weighted case. In the third problem, we are given a set P of n points that are moving in the plane, the problem is to compute a spanning tree for these moving points that does not change its combinatorial structure during the point movement such that the bottleneck weight of the spanning tree (i.e., the largest Euclidean length of all edges) during the whole movement is minimized. We present an algorithm that runs in O(n4/3 log3 n) time. The fourth problem is unit-disk range reporting in which we are given a set P of n points in the plane and a value r, we need to construct a data structure so that given any query disk of radius r, all points of P in the disk can be reported efficiently. We build a data structure of O(n) space in O(n log n) time that can answer each query in O(k + log n) time, where k is the output size. The time complexity of our algorithm is the same as the previous result but our approach is much simpler. Finally, for the problem of distance selection, we are given a set P of n points in the plane and an integer 1 ≤ k ≤ (n2), the distance selection problem is to find the k-th smallest interpoint distance among all pairs of points of p. We propose an algorithm that runs in O(n4/3 log n) time. Our techniques yield two algorithmic frameworks for solving geometric optimization problems. Many algorithms and techniques developed in this dissertation are quite general and fundamental, and we believe they will find other applications in future

Efficient Data Structures for Partial Orders, Range Modes, and Graph Cuts

This thesis considers the study of data structures from the perspective of the theoretician, with a focus on simplicity and practicality. We consider both the time complexity as well as space usage of proposed solutions. Topics discussed fall in three main categories: partial order representation, range modes, and graph cuts. We consider two problems in partial order representation. The first is a data structure to represent a lattice. A lattice is a partial order where the set of elements larger than any two elements x and y are all larger than an element z, known as the join of x and y; a similar condition holds for elements smaller than any two elements. Our data structure is the first correct solution that can simultaneously compute joins and the inverse meet operation in sublinear time while also using subquadratic space. The second is a data structure to support queries on a dynamic set of one-dimensional ordered data; that is, essentially any operation computable on a binary search tree. We develop a data structure that is able to interpolate between binary search trees and efficient priority queues, offering more-efficient insertion times than the former when query distribution is non-uniform. We also consider static and dynamic exact and approximate range mode. Given one-dimensional data, the range mode problem is to compute the mode of a subinterval of the data. In the dynamic range mode problem, insertions and deletions are permitted. For the approximate problem, the element returned is to have frequency no less than a factor (1+epsilon) of the true mode, for some epsilon > 0. Our results include a linear-space dynamic exact range mode data structure that simultaneously improves on best previous operation complexity and an exact dynamic range mode data structure that breaks the Theta(n^(2/3)) time per operation barrier. For approximate range mode, we develop a static succinct data structure offering a logarithmic-factor space improvement and give the first dynamic approximate range mode data structure. We also consider approximate range selection. The final category discussed is graph and dynamic graph algorithms. We develop an optimal offline data structure for dynamic 2- and 3- edge and vertex connectivity. Here, the data structure is given the entire sequence of operations in advance, and the dynamic operations are edge insertion and removal. Finally, we give a simplification of Karger's near-linear time minimum cut algorithm, utilizing heavy-light decomposition and iteration in place of dynamic programming in the subroutine to find a minimum cut of a graph G that cuts at most two edges of a spanning tree T of G

Comparing Boolean Operation Methods on 3D Solids

Geometric engines are developed to give answers on geometrical queries, such as, what is the volume of a shape? Developing, testing and maintaining a geometric engine which can be used generically to answer arbitrary geometric queries is a tedious and time consuming task. Thousands of work hours are being spent towards this purpose. A very important element of such geometric engines is the Boolean operations on 3D objects. Boolean operations can be used to develop powerful tools for CAD/CAM applications, by which, end users can save thousands of work hours during modeling. While robust Boolean operations on 3D objects are difficult to implement, once available, many geometric queries can be reduced to a collection of Boolean operations. This reduction would save thousands of hours for the developers of such CAD/CAM applications. The goal of this thesis is to compare the Boolean implementation of Tekla Structures with the Boolean implementation of CGAL and a recently introduced method, EMBER. Using the results of this thesis, Tekla Structures’ currently unidentified vulnerabilities in its Boolean implementation can be identified and thus, improved. Quantitative results showed that Tekla Structures’ Boolean implementation, while being fast, suffered in terms of robustness during the union and difference operations with respect to CGAL and EMBER while doing remarkably well in the intersection operations

LIPIcs, Volume 258, SoCG 2023, Complete Volume

LIPIcs, Volume 258, SoCG 2023, Complete Volum

Lower bound techniques for data structures

Thesis (Ph. D.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 2008.Includes bibliographical references (p. 135-143).We describe new techniques for proving lower bounds on data-structure problems, with the following broad consequences: * the first [omega](lg n) lower bound for any dynamic problem, improving on a bound that had been standing since 1989; * for static data structures, the first separation between linear and polynomial space. Specifically, for some problems that have constant query time when polynomial space is allowed, we can show [omega](lg n/ lg lg n) bounds when the space is O(n - polylog n). Using these techniques, we analyze a variety of central data-structure problems, and obtain improved lower bounds for the following: * the partial-sums problem (a fundamental application of augmented binary search trees); * the predecessor problem (which is equivalent to IP lookup in Internet routers); * dynamic trees and dynamic connectivity; * orthogonal range stabbing. * orthogonal range counting, and orthogonal range reporting; * the partial match problem (searching with wild-cards); * (1 + [epsilon])-approximate near neighbor on the hypercube; * approximate nearest neighbor in the l[infinity] metric. Our new techniques lead to surprisingly non-technical proofs. For several problems, we obtain simpler proofs for bounds that were already known.by Mihai Pǎtraşcu.Ph.D

Dynamic Approximate All-Pairs Shortest Paths: Breaking the O(mn) Barrier and Derandomization

We study dynamic $(1+\epsilon)$-approximation algorithms for the all-pairs shortest paths problem in unweighted undirected $n$-node $m$-edge graphs under edge deletions. The fastest algorithm for this problem is a randomized algorithm with a total update time of $\tilde O(mn/\epsilon)$ and constant query time by Roditty and Zwick [FOCS 2004]. The fastest deterministic algorithm is from a 1981 paper by Even and Shiloach [JACM 1981]; it has a total update time of $O(mn^2)$ and constant query time. We improve these results as follows: (1) We present an algorithm with a total update time of $\tilde O(n^{5/2}/\epsilon)$ and constant query time that has an additive error of $2$ in addition to the $1+\epsilon$ multiplicative error. This beats the previous $\tilde O(mn/\epsilon)$ time when $m=\Omega(n^{3/2})$. Note that the additive error is unavoidable since, even in the static case, an $O(n^{3-\delta})$-time (a so-called truly subcubic) combinatorial algorithm with $1+\epsilon$ multiplicative error cannot have an additive error less than $2-\epsilon$, unless we make a major breakthrough for Boolean matrix multiplication [Dor et al. FOCS 1996] and many other long-standing problems [Vassilevska Williams and Williams FOCS 2010]. The algorithm can also be turned into a $(2+\epsilon)$-approximation algorithm (without an additive error) with the same time guarantees, improving the recent $(3+\epsilon)$-approximation algorithm with $\tilde O(n^{5/2+O(\sqrt{\log{(1/\epsilon)}/\log n})})$ running time of Bernstein and Roditty [SODA 2011] in terms of both approximation and time guarantees. (2) We present a deterministic algorithm with a total update time of $\tilde O(mn/\epsilon)$ and a query time of $O(\log\log n)$. The algorithm has a multiplicative error of $1+\epsilon$ and gives the first improved deterministic algorithm since 1981. It also answers an open question raised by Bernstein [STOC 2013].Comment: A preliminary version was presented at the 2013 IEEE 54th Annual Symposium on Foundations of Computer Science (FOCS 2013