Showing papers by "John Iacono published in 2021"

Worst-Case Efficient Dynamic Geometric Independent Set

Abstract: We consider the problem of maintaining an approximate maximum independent set of geometric objects under insertions and deletions. We present a data structure that maintains a constant-factor approximate maximum independent set for broad classes of fat objects in d dimensions, where d is assumed to be a constant, in sublinear worst-case update time. This gives the first results for dynamic independent set in a wide variety of geometric settings, such as disks, fat polygons, and their high-dimensional equivalents. For axis-aligned squares and hypercubes, our result improves upon all (recently announced) previous works. We obtain, in particular, a dynamic (4+e)-approximation for squares, with O(log⁴ n) worst-case update time. Our result is obtained via a two-level approach. First, we develop a dynamic data structure which stores all objects and provides an approximate independent set when queried, with output-sensitive running time. We show that via standard methods such a structure can be used to obtain a dynamic algorithm with amortized update time bounds. Then, to obtain worst-case update time algorithms, we develop a generic deamortization scheme that with each insertion/deletion keeps (i) the update time bounded and (ii) the number of changes in the independent set constant. We show that such a scheme is applicable to fat objects by showing an appropriate generalization of a separator theorem. Interestingly, we show that our deamortization scheme is also necessary in order to obtain worst-case update bounds: If for a class of objects our scheme is not applicable, then no constant-factor approximation with sublinear worst-case update time is possible. We show that such a lower bound applies even for seemingly simple classes of geometric objects including axis-aligned rectangles in the plane.

Belga B-Trees

Abstract: We revisit self-adjusting external memory tree data structures, which combine the optimal (and practical) worst-case I/O performances of B-trees, while adapting to the online distribution of queries Our approach is analogous to undergoing efforts in the BST model, where Tango Trees (Demaine et al 2007) were shown to be \(O(\log \log N)\)-competitive with the runtime of the best offline binary search tree on every sequence of searches Here we formalize the B-Tree model as a natural generalization of the BST model We prove lower bounds for the B-Tree model, and introduce a B-Tree model data structure, the Belga B-tree, that executes any sequence of searches within a \(O(\log \log N)\) factor of the best offline B-tree model algorithm, provided \(B=\log ^{O(1)}N\) We also show how to transform any static BST into a static B-tree which is faster by a \(\varTheta (\log B)\) factor; the transformation is randomized and we show that randomization is necessary to obtain any significant speedup

Fragile Complexity of Adaptive Algorithms

Abstract: The fragile complexity of a comparison-based algorithm is $f(n)$ if each input element participates in $O(f(n))$ comparisons. In this paper, we explore the fragile complexity of algorithms adaptive to various restrictions on the input, i.e., algorithms with a fragile complexity parameterized by a quantity other than the input size n. We show that searching for the predecessor in a sorted array has fragile complexity ${\Theta}(\log k)$, where $k$ is the rank of the query element, both in a randomized and a deterministic setting. For predecessor searches, we also show how to optimally reduce the amortized fragile complexity of the elements in the array. We also prove the following results: Selecting the $k$-th smallest element has expected fragile complexity $O(\log \log k)$ for the element selected. Deterministically finding the minimum element has fragile complexity ${\Theta}(\log(Inv))$ and ${\Theta}(\log(Runs))$, where $Inv$ is the number of inversions in a sequence and $Runs$ is the number of increasing runs in a sequence. Deterministically finding the median has fragile complexity $O(\log(Runs) + \log \log n)$ and ${\Theta}(\log(Inv))$. Deterministic sorting has fragile complexity ${\Theta}(\log(Inv))$ but it has fragile complexity ${\Theta}(\log n)$ regardless of the number of runs.

Worst-Case Efficient Dynamic Geometric Independent Set

Abstract: We consider the problem of maintaining an approximate maximum independent set of geometric objects under insertions and deletions. We present data structures that maintain a constant-factor approximate maximum independent set for broad classes of fat objects in $d$ dimensions, where $d$ is assumed to be a constant, in sublinear \textit{worst-case} update time. This gives the first results for dynamic independent set in a wide variety of geometric settings, such as disks, fat polygons, and their high-dimensional equivalents. For axis-aligned squares and hypercubes, our result improves upon all (recently announced) previous works. We obtain, in particular, a dynamic $(4+\epsilon)$-approximation for squares, with $O(\log^4 n)$ worst-case update time. Our result is obtained via a two-level approach. First, we develop a dynamic data structure which stores all objects and provides an approximate independent set when queried, with output-sensitive running time. We show that via standard methods such a structure can be used to obtain a dynamic algorithm with \textit{amortized} update time bounds. Then, to obtain worst-case update time algorithms, we develop a generic deamortization scheme that with each insertion/deletion keeps (i) the update time bounded and (ii) the number of changes in the independent set constant. We show that such a scheme is applicable to fat objects by showing an appropriate generalization of a separator theorem. Interestingly, we show that our deamortization scheme is also necessary in order to obtain worst-case update bounds: If for a class of objects our scheme is not applicable, then no constant-factor approximation with sublinear worst-case update time is possible. We show that such a lower bound applies even for seemingly simple classes of geometric objects including axis-aligned rectangles in the plane.

Approximability of (Simultaneous) Class Cover for Boxes

Abstract: Bereg et al. (2012) introduced the Boxes Class Cover problem, which has its roots in classification and clustering applications: Given a set of n points in the plane, each colored red or blue, find the smallest cardinality set of axis-aligned boxes whose union covers the red points without covering any blue point. In this paper we give an alternative proof of APX-hardness for this problem, which also yields an explicit lower bound on its approximability. Our proof also directly applies when restricted to sets of points in general position and to the case where so-called half-strips are considered instead of boxes, which is a new result. We also introduce a symmetric variant of this problem, which we call Simultaneous Boxes Class Cover and can be stated as follows: Given a set S of n points in the plane, each colored red or blue, find the smallest cardinality set of axis-aligned boxes which together cover S such that all boxes cover only points of the same color and no box covering a red point intersects a box covering a blue point. We show that this problem is also APX-hard and give a polynomial-time constant-factor approximation algorithm.

Fragile Complexity of Adaptive Algorithms

Abstract: The fragile complexity of a comparison-based algorithm is f(n) if each input element participates in O(f(n)) comparisons. In this paper, we explore the fragile complexity of algorithms adaptive to various restrictions on the input, i.e., algorithms with a fragile complexity parameterized by a quantity other than the input size n. We show that searching for the predecessor in a sorted array has fragile complexity \(\varTheta (\log k)\), where k is the rank of the query element, both in a randomized and a deterministic setting. For predecessor searches, we also show how to optimally reduce the amortized fragile complexity of the elements in the array. We also prove the following results: Selecting the kth smallest element has expected fragile complexity \(O(\log \log k)\) for the element selected. Deterministically finding the minimum element has fragile complexity \(\varTheta (\log (\mathrm {Inv}))\) and \(\varTheta (\log (\mathrm {Runs}))\), where \(\mathrm {Inv}\) is the number of inversions in a sequence and \(\mathrm {Runs}\) is the number of increasing runs in a sequence. Deterministically finding the median has fragile complexity \(O(\log (\mathrm {Runs}) + \log \log n)\) and \(\varTheta (\log (\mathrm {Inv}))\). Deterministic sorting has fragile complexity \(\varTheta (\log (\mathrm {Inv}))\) but it has fragile complexity \(\varTheta (\log n)\) regardless of the number of runs.

Dynamic Schnyder Woods.

Abstract: A realizer, commonly known as Schnyder woods, of a triangulation is a partition of its interior edges into three oriented rooted trees. A flip in a realizer is a local operation that transforms one realizer into another. Two types of flips in a realizer have been introduced: colored flips and cycle flips. A corresponding flip graph is defined for each of these two types of flips. The vertex sets are the realizers, and two realizers are adjacent if they can be transformed into each other by one flip. In this paper we study the relation between these two types of flips and their corresponding flip graphs. We show that a cycle flip can be obtained from linearly many colored flips. We also prove an upper bound of $O(n^2)$ on the diameter of the flip graph of realizers defined by colored flips. In addition, a data structure is given to dynamically maintain a realizer over a sequence of colored flips which supports queries, including getting a node's barycentric coordinates, in $O(\log n)$ time per flip or query.

Subquadratic Algorithms for Some \textsc{3Sum}-Hard Geometric Problems in the Algebraic Decision Tree Model.

Abstract: We present subquadratic algorithms in the algebraic decision-tree model for several \textsc{3Sum}-hard geometric problems, all of which can be reduced to the following question: Given two sets $A$, $B$, each consisting of $n$ pairwise disjoint segments in the plane, and a set $C$ of $n$ triangles in the plane, we want to count, for each triangle $\Delta\in C$, the number of intersection points between the segments of $A$ and those of $B$ that lie in $\Delta$. The problems considered in this paper have been studied by Chan~(2020), who gave algorithms that solve them, in the standard real-RAM model, in $O((n^2/\log^2n)\log^{O(1)}\log n)$ time. We present solutions in the algebraic decision-tree model whose cost is $O(n^{60/31+\varepsilon})$, for any $\varepsilon>0$. Our approach is based on a primal-dual range searching mechanism, which exploits the multi-level polynomial partitioning machinery recently developed by Agarwal, Aronov, Ezra, and Zahl~(2020). A key step in the procedure is a variant of point location in arrangements, say of lines in the plane, which is based solely on the \emph{order type} of the lines, a "handicap" that turns out to be beneficial for speeding up our algorithm.

An Instance-optimal Algorithm for Bichromatic Rectangular Visibility

Abstract: Afshani, Barbay and Chan (2017) introduced the notion of instance-optimal algorithm in the order-oblivious setting. An algorithm A is instance-optimal in the order-oblivious setting for a certain class of algorithms A* if the following hold: - A takes as input a sequence of objects from some domain; - for any instance $\sigma$ and any algorithm A' in A*, the runtime of A on $\sigma$ is at most a constant factor removed from the runtime of A' on the worst possible permutation of $\sigma$. If we identify permutations of a sequence as representing the same instance, this essentially states that A is optimal on every possible input (and not only in the worst case). We design instance-optimal algorithms for the problem of reporting, given a bichromatic set of points in the plane S, all pairs consisting of points of different color which span an empty axis-aligned rectangle (or reporting all points which appear in such a pair). This problem has applications for training-set reduction in nearest-neighbour classifiers. It is also related to the problem consisting of finding the decision boundaries of a euclidean nearest-neighbour classifier, for which Bremner et al. (2005) gave an optimal output-sensitive algorithm. By showing the existence of an instance-optimal algorithm in the order-oblivious setting for this problem we push the methods of Afshani et al. closer to their limits by adapting and extending them to a setting which exhibits highly non-local features. Previous problems for which instance-optimal algorithms were proven to exist were based solely on local relationships between points in a set.