@article{12086, abstract = {We present a simple algorithm for computing higher-order Delaunay mosaics that works in Euclidean spaces of any finite dimensions. The algorithm selects the vertices of the order-k mosaic from incrementally constructed lower-order mosaics and uses an algorithm for weighted first-order Delaunay mosaics as a black-box to construct the order-k mosaic from its vertices. Beyond this black-box, the algorithm uses only combinatorial operations, thus facilitating easy implementation. We extend this algorithm to compute higher-order α-shapes and provide open-source implementations. We present experimental results for properties of higher-order Delaunay mosaics of random point sets.}, author = {Edelsbrunner, Herbert and Osang, Georg F}, issn = {1432-0541}, journal = {Algorithmica}, pages = {277--295}, publisher = {Springer Nature}, title = {{A simple algorithm for higher-order Delaunay mosaics and alpha shapes}}, doi = {10.1007/s00453-022-01027-6}, volume = {85}, year = {2023}, } @article{14043, abstract = {Over the last two decades, a significant line of work in theoretical algorithms has made progress in solving linear systems of the form Lx=b, where L is the Laplacian matrix of a weighted graph with weights w(i,j)>0 on the edges. The solution x of the linear system can be interpreted as the potentials of an electrical flow in which the resistance on edge (i, j) is 1/w(i, j). Kelner et al. (in: Proceedings of the 45th Annual ACM Symposium on the Theory of Computing, pp 911–920, 2013. https://doi.org/10.1145/2488608.2488724) give a combinatorial, near-linear time algorithm that maintains the Kirchoff Current Law, and gradually enforces the Kirchoff Potential Law by updating flows around cycles (cycle toggling). In this paper, we consider a dual version of the algorithm that maintains the Kirchoff Potential Law, and gradually enforces the Kirchoff Current Law by cut toggling: each iteration updates all potentials on one side of a fundamental cut of a spanning tree by the same amount. We prove that this dual algorithm also runs in a near-linear number of iterations. We show, however, that if we abstract cut toggling as a natural data structure problem, this problem can be reduced to the online vector–matrix-vector problem, which has been conjectured to be difficult for dynamic algorithms (Henzinger et al., in: Proceedings of the 47th Annual ACM Symposium on the Theory of Computing, pp 21–30, 2015. https://doi.org/10.1145/2746539.2746609). The conjecture implies that the data structure does not have an O(n1−ϵ) time algorithm for any ϵ>0, and thus a straightforward implementation of the cut-toggling algorithm requires essentially linear time per iteration. To circumvent the lower bound, we batch update steps, and perform them simultaneously instead of sequentially. An appropriate choice of batching leads to an O˜(m1.5) time cut-toggling algorithm for solving Laplacian systems. Furthermore, we show that if we sparsify the graph and call our algorithm recursively on the Laplacian system implied by batching and sparsifying, we can reduce the running time to O(m1+ϵ) for any ϵ>0. Thus, the dual cut-toggling algorithm can achieve (almost) the same running time as its primal cycle-toggling counterpart.}, author = {Henzinger, Monika H and Jin, Billy and Peng, Richard and Williamson, David P.}, issn = {1432-0541}, journal = {Algorithmica}, pages = {2680--3716}, publisher = {Springer Nature}, title = {{A combinatorial cut-toggling algorithm for solving Laplacian linear systems}}, doi = {10.1007/s00453-023-01154-8}, volume = {85}, year = {2023}, } @article{8286, abstract = {We consider the following dynamic load-balancing process: given an underlying graph G with n nodes, in each step t≥ 0, one unit of load is created, and placed at a randomly chosen graph node. In the same step, the chosen node picks a random neighbor, and the two nodes balance their loads by averaging them. We are interested in the expected gap between the minimum and maximum loads at nodes as the process progresses, and its dependence on n and on the graph structure. Variants of the above graphical balanced allocation process have been studied previously by Peres, Talwar, and Wieder [Peres et al., 2015], and by Sauerwald and Sun [Sauerwald and Sun, 2015]. These authors left as open the question of characterizing the gap in the case of cycle graphs in the dynamic case, where weights are created during the algorithm’s execution. For this case, the only known upper bound is of 𝒪(n log n), following from a majorization argument due to [Peres et al., 2015], which analyzes a related graphical allocation process. In this paper, we provide an upper bound of 𝒪 (√n log n) on the expected gap of the above process for cycles of length n. We introduce a new potential analysis technique, which enables us to bound the difference in load between k-hop neighbors on the cycle, for any k ≤ n/2. We complement this with a "gap covering" argument, which bounds the maximum value of the gap by bounding its value across all possible subsets of a certain structure, and recursively bounding the gaps within each subset. We provide analytical and experimental evidence that our upper bound on the gap is tight up to a logarithmic factor. }, author = {Alistarh, Dan-Adrian and Nadiradze, Giorgi and Sabour, Amirmojtaba}, issn = {1432-0541}, journal = {Algorithmica}, location = {Virtual, Online; Germany}, publisher = {Springer Nature}, title = {{Dynamic averaging load balancing on cycles}}, doi = {10.1007/s00453-021-00905-9}, year = {2021}, } @article{11675, abstract = {We consider the problems of maintaining an approximate maximum matching and an approximate minimum vertex cover in a dynamic graph undergoing a sequence of edge insertions/deletions. Starting with the seminal work of Onak and Rubinfeld (in: Proceedings of the ACM symposium on theory of computing (STOC), 2010), this problem has received significant attention in recent years. Very recently, extending the framework of Baswana et al. (in: Proceedings of the IEEE symposium on foundations of computer science (FOCS), 2011) , Solomon (in: Proceedings of the IEEE symposium on foundations of computer science (FOCS), 2016) gave a randomized dynamic algorithm for this problem that has an approximation ratio of 2 and an amortized update time of O(1) with high probability. This algorithm requires the assumption of an oblivious adversary, meaning that the future sequence of edge insertions/deletions in the graph cannot depend in any way on the algorithm’s past output. A natural way to remove the assumption on oblivious adversary is to give a deterministic dynamic algorithm for the same problem in O(1) update time. In this paper, we resolve this question. We present a new deterministic fully dynamic algorithm that maintains a O(1)-approximate minimum vertex cover and maximum fractional matching, with an amortized update time of O(1). Previously, the best deterministic algorithm for this problem was due to Bhattacharya et al. (in: Proceedings of the ACM-SIAM symposium on discrete algorithms (SODA), 2015); it had an approximation ratio of (2+ε) and an amortized update time of O(logn/ε2). Our result can be generalized to give a fully dynamic O(f3)-approximate algorithm with O(f2) amortized update time for the hypergraph vertex cover and fractional hypergraph matching problem, where every hyperedge has at most f vertices.}, author = {Bhattacharya, Sayan and Chakrabarty, Deeparnab and Henzinger, Monika H}, issn = {1432-0541}, journal = {Algorithmica}, keywords = {Dynamic algorithms, Data structures, Graph algorithms, Matching, Vertex cover}, number = {4}, pages = {1057--1080}, publisher = {Springer Nature}, title = {{Deterministic dynamic matching in O(1) update time}}, doi = {10.1007/s00453-019-00630-4}, volume = {82}, year = {2020}, } @article{11674, abstract = {In this paper, we study the problem of opening centers to cluster a set of clients in a metric space so as to minimize the sum of the costs of the centers and of the cluster radii, in a dynamic environment where clients arrive and depart, and the solution must be updated efficiently while remaining competitive with respect to the current optimal solution. We call this dynamic sum-of-radii clustering problem. We present a data structure that maintains a solution whose cost is within a constant factor of the cost of an optimal solution in metric spaces with bounded doubling dimension and whose worst-case update time is logarithmic in the parameters of the problem.}, author = {Henzinger, Monika H and Leniowski, Dariusz and Mathieu, Claire}, issn = {1432-0541}, journal = {Algorithmica}, number = {11}, pages = {3183--3194}, publisher = {Springer Nature}, title = {{Dynamic clustering to minimize the sum of radii}}, doi = {10.1007/s00453-020-00721-7}, volume = {82}, year = {2020}, } @article{11676, abstract = {We study the problem of maximizing a monotone submodular function with viability constraints. This problem originates from computational biology, where we are given a phylogenetic tree over a set of species and a directed graph, the so-called food web, encoding viability constraints between these species. These food webs usually have constant depth. The goal is to select a subset of k species that satisfies the viability constraints and has maximal phylogenetic diversity. As this problem is known to be NP-hard, we investigate approximation algorithms. We present the first constant factor approximation algorithm if the depth is constant. Its approximation ratio is (1−1e√). This algorithm not only applies to phylogenetic trees with viability constraints but for arbitrary monotone submodular set functions with viability constraints. Second, we show that there is no (1−1/e+ϵ)-approximation algorithm for our problem setting (even for additive functions) and that there is no approximation algorithm for a slight extension of this setting.}, author = {Dvořák, Wolfgang and Henzinger, Monika H and Williamson, David P.}, issn = {1432-0541}, journal = {Algorithmica}, keywords = {Approximation algorithms, Submodular functions, Phylogenetic diversity, Viability constraints}, number = {1}, pages = {152--172}, publisher = {Springer Nature}, title = {{Maximizing a submodular function with viability constraints}}, doi = {10.1007/s00453-015-0066-y}, volume = {77}, year = {2017}, } @article{11679, abstract = {We are given a set T = {T 1 ,T 2 , . . .,T k } of rooted binary trees, each T i leaf-labeled by a subset L(Ti)⊂{1,2,...,n} . If T is a tree on {1,2, . . .,n }, we let T|L denote the minimal subtree of T induced by the nodes of L and all their ancestors. The consensus tree problem asks whether there exists a tree T * such that, for every i , T∗|L(Ti) is homeomorphic to T i . We present algorithms which test if a given set of trees has a consensus tree and if so, construct one. The deterministic algorithm takes time min{O(N n 1/2 ), O(N+ n 2 log n )}, where N=∑i|Ti| , and uses linear space. The randomized algorithm takes time O(N log3 n) and uses linear space. The previous best for this problem was a 1981 O(Nn) algorithm by Aho et al. Our faster deterministic algorithm uses a new efficient algorithm for the following interesting dynamic graph problem: Given a graph G with n nodes and m edges and a sequence of b batches of one or more edge deletions, then, after each batch, either find a new component that has just been created or determine that there is no such component. For this problem, we have a simple algorithm with running time O(n 2 log n + b 0 min{n 2 , m log n }), where b 0 is the number of batches which do not result in a new component. For our particular application, b0≤1 . If all edges are deleted, then the best previously known deterministic algorithm requires time O(mn−−√) to solve this problem. We also present two applications of these consensus tree algorithms which solve other problems in computational evolutionary biology.}, author = {Henzinger, Monika H and King, V. and Warnow, T.}, issn = {1432-0541}, journal = {Algorithmica}, keywords = {Algorithms, Data structures, Evolutionary biology, Theory of databases}, pages = {1--13}, publisher = {Springer Nature}, title = {{Constructing a tree from homeomorphic subtrees, with applications to computational evolutionary biology}}, doi = {10.1007/pl00009268}, volume = {24}, year = {1999}, } @article{11681, abstract = {We prove lower bounds on the complexity of maintaining fully dynamic k -edge or k -vertex connectivity in plane graphs and in (k-1) -vertex connected graphs. We show an amortized lower bound of Ω (log n / {k (log log n} + log b)) per edge insertion, deletion, or query operation in the cell probe model, where b is the word size of the machine and n is the number of vertices in G . We also show an amortized lower bound of Ω (log n /(log log n + log b)) per operation for fully dynamic planarity testing in embedded graphs. These are the first lower bounds for fully dynamic connectivity problems.}, author = {Henzinger, Monika H and Fredman, M. L.}, issn = {1432-0541}, journal = {Algorithmica}, keywords = {Dynamic planarity testing, Dynamic connectivity testing, Lower bounds, Cell probe model}, number = {3}, pages = {351--362}, publisher = {Springer Nature}, title = {{Lower bounds for fully dynamic connectivity problems in graphs}}, doi = {10.1007/pl00009228}, volume = {22}, year = {1998}, } @article{11680, abstract = {We present a model for edge updates with restricted randomness in dynamic graph algorithms and a general technique for analyzing the expected running time of an update operation. This model is able to capture the average case in many applications, since (1) it allows restrictions on the set of edges which can be used for insertions and (2) the type (insertion or deletion) of each update operation is arbitrary, i.e., not random. We use our technique to analyze existing and new dynamic algorithms for the following problems: maximum cardinality matching, minimum spanning forest, connectivity, 2-edge connectivity, k -edge connectivity, k -vertex connectivity, and bipartiteness. Given a random graph G with m 0 edges and n vertices and a sequence of l update operations such that the graph contains m i edges after operation i , the expected time for performing the updates for any l is O(llogn+∑li=1n/m−−√i) in the case of minimum spanning forests, connectivity, 2-edge connectivity, and bipartiteness. The expected time per update operation is O(n) in the case of maximum matching. We also give improved bounds for k -edge and k -vertex connectivity. Additionally we give an insertions-only algorithm for maximum cardinality matching with worst-case O(n) amortized time per insertion.}, author = {Alberts, D. and Henzinger, Monika H}, issn = {1432-0541}, journal = {Algorithmica}, keywords = {Dynamic graph algorithm, Average-case analysis, Minimum spanning forest, Connectivity, Bipartiteness, Maximum matching.}, pages = {31--60}, publisher = {Springer Nature}, title = {{Average-case analysis of dynamic graph algorithms}}, doi = {10.1007/pl00009186}, volume = {20}, year = {1998}, } @article{4027, abstract = {Questions about lines in space arise frequently as subproblems in three-dimensional computational geometry. In this paper we study a number of fundamental combinatorial and algorithmic problems involving arrangements of n lines in three-dimensional space. Our main results include: 1. A tight Θ(n2) bound on the maximum combinatorial description complexity of the set of all oriented lines that have specified orientations relative to the n given lines. 2. A similar bound of Θ(n3) for the complexity of the set of all lines passing above the n given lines. 3. A preprocessing procedure using O(n2+ε) time and storage, for any ε > 0, that builds a structure supporting O(logn)-time queries for testing if a line lies above all the given lines. 4. An algorithm that tests the "towering property" in O(n4/3+ε) time, for any ε > 0: do n given red lines lie all above n given blue lines? The tools used to obtain these and other results include Plücker coordinates for lines in space and ε-nets for various geometric range spaces.}, author = {Chazelle, Bernard and Edelsbrunner, Herbert and Guibas, Leonidas and Sharir, Micha and Stolfi, Jorge}, issn = {0178-4617}, journal = {Algorithmica}, number = {5}, pages = {428 -- 447}, publisher = {Springer}, title = {{Lines in space: Combinatorics and algorithms}}, doi = {10.1007/BF01955043}, volume = {15}, year = {1996}, } @article{4026, abstract = {A set of n weighted points in general position in R(d) defines a unique regular triangulation. This paper proves that if the points are added one by one, then flipping in a topological order will succeed in constructing this triangulation. If, in addition, the points are added in a random sequence and the history of the flips is used for locating the next point, then the algorithm takes expected time at most O(n log n + n(inverted left perpendicular d/2 inverted right perpendicular)). Under the assumption that the points and weights are independently and identically distributed, the expected running time is between proportional to and a factor log n more than the expected size of the regular triangulation. The expectation is over choosing the points and over independent coin-flips performed by the algorithm.}, author = {Edelsbrunner, Herbert and Shah, Nimish}, issn = {0178-4617}, journal = {Algorithmica}, number = {3}, pages = {223 -- 241}, publisher = {Springer}, title = {{Incremental topological flipping works for regular triangulations}}, doi = {10.1007/BF01975867}, volume = {15}, year = {1996}, } @article{11677, abstract = {We present an algorithm for maintaining the biconnected components of a graph during a sequence of edge insertions and deletions. It requires linear storage and preprocessing time. The amortized running time for insertions and for deletions isO(m 2/3 ), wherem is the number of edges in the graph. Any query of the form ‘Are the verticesu andv biconnected?’ can be answered in timeO(1). This is the first sublinear algorithm for this problem. We can also output all articulation points separating any two vertices efficiently. If the input is a plane graph, the amortized running time for insertions and deletions drops toO(√n logn) and the query time isO(log2 n), wheren is the number of vertices in the graph. The best previously known solution takes timeO(n 2/3 ) per update or query.}, author = {Henzinger, Monika H}, issn = {1432-0541}, journal = {Algorithmica}, number = {6}, pages = {503--538}, publisher = {Springer Nature}, title = {{Fully dynamic biconnectivity in graphs}}, doi = {10.1007/bf01189067}, volume = {13}, year = {1995}, } @article{4039, abstract = {Let P be a simple polygon with n vertices. We present a simple decomposition scheme that partitions the interior of P into O(n) so-called geodesic triangles, so that any line segment interior to P crosses at most 2 log n of these triangles. This decomposition can be used to preprocess P in a very simple manner, so that any ray-shooting query can be answered in time O(log n). The data structure requires O(n) storage and O(n log n) preprocessing time. By using more sophisticated techniques, we can reduce the preprocessing time to O(n). We also extend our general technique to the case of ray shooting amidst k polygonal obstacles with a total of n edges, so that a query can be answered in O(√ log n) time.}, author = {Chazelle, Bernard and Edelsbrunner, Herbert and Grigni, Michelangelo and Guibas, Leonidas and Hershberger, John and Sharir, Micha and Snoeyink, Jack}, issn = {0178-4617}, journal = {Algorithmica}, number = {1}, pages = {54 -- 68}, publisher = {Springer}, title = {{Ray shooting in polygons using geodesic triangulations}}, doi = {10.1007/BF01377183}, volume = {12}, year = {1994}, } @article{4038, abstract = {We consider a variety of problems on the interaction between two sets of line segments in two and three dimensions. These problems range from counting the number of intersecting pairs between m blue segments and n red segments in the plane (assuming that two line segments are disjoint if they have the same color) to finding the smallest vertical distance between two nonintersecting polyhedral terrains in three-dimensional space. We solve these problems efficiently by using a variant of the segment tree. For the three-dimensional problems we also apply a variety of recent combinatorial and algorithmic techniques involving arrangements of lines in three-dimensional space, as developed in a companion paper.}, author = {Chazelle, Bernard and Edelsbrunner, Herbert and Guibas, Leonidas and Sharir, Micha}, issn = {0178-4617}, journal = {Algorithmica}, number = {2}, pages = {116 -- 132}, publisher = {Springer}, title = {{Algorithms for bichromatic line-segment problems and polyhedral terrains}}, doi = {10.1007/BF01182771}, volume = {11}, year = {1994}, } @article{4075, abstract = {A key problem in computational geometry is the identification of subsets of a point set having particular properties. We study this problem for the properties of convexity and emptiness. We show that finding empty triangles is related to the problem of determining pairs of vertices that see each other in a star-shaped polygon. A linear-time algorithm for this problem which is of independent interest yields an optimal algorithm for finding all empty triangles. This result is then extended to an algorithm for finding empty convex r-gons (r> 3) and for determining a largest empty convex subset. Finally, extensions to higher dimensions are mentioned.}, author = {Dobkin, David and Edelsbrunner, Herbert and Overmars, Mark}, issn = {1432-0541}, journal = {Algorithmica}, number = {4}, pages = {561 -- 571}, publisher = {Springer}, title = {{Searching for empty convex polygons}}, doi = {10.1007/BF01840404}, volume = {5}, year = {1990}, } @article{3580, abstract = {An edge-skeleton in an arrangementA(H) of a finite set of planes inE 3 is a connected collection of edges inA(H). We give a method that constructs a skeleton inO(√n logn) time per edge. This method implies new and more efficient algorithms for a number of structures in computational geometry including order-k power diagrams inE 2 and space cutting trees inE 3. We also give a novel method for handling special cases which has the potential to substantially decrease the amount of effort needed to implement geometric algorithms.}, author = {Edelsbrunner, Herbert}, issn = {1432-0541}, journal = {Algorithmica}, number = {1-4}, pages = {93 -- 109}, publisher = {Springer}, title = {{Edge-skeletons in arrangements with applications}}, doi = {10.1007/BF01840438}, volume = {1}, year = {1986}, }