Radio Networks (RN) is one of the fundamental models for network communication where nodes can broadcast messages locally but their simultaneous transmissions can interfere with each other at their shared neighbors. This work focuses on performing the very fundamental primitive of Local Broadcast, in spite of the interferences. We investigate to what extent local knowledge, called advice, relating to the 2-local domination number gamma 2 may speed up Local Broadcast. Specifically for each node and some dominating set, knowledge about some neighboring dominating node and the local number among the neighbors of that dominating node. We show that such advice is sufficient to build an efficient oblivious transmission schedule. Along those lines, we present three algorithms trading the level of adaptiveness (from oblivious to adaptive) for bits of advice per node (from O(log(Delta gamma(2))) to 1). All our algorithms complete Local Broadcast in (O) over tilde(Delta gamma(2)(2)) rounds, where Delta is the maximum degree of the network. On the side of lower bounds, we show that, for each quasi-adaptive deterministic Local Broadcast algorithm, there is some RN that requires Omega(min{(min{Delta,gamma(2)}/ log n)(2), n}) communication rounds, where n is the number of network nodes. In quasi-adaptive protocols nodes may stop executing once its computational task is completed. To the best of our knowledge, this is the first (nearly) quadratic Local Broadcast (same message for all neighbors) lower bound in the RN model. Our lower bound is stronger than previous works in multiple ways: i) it is nearly quadratically better than the best known general lower bound for this class of algorithms, ii) it applies to a wider class of algorithms than previous work for fully oblivious, iii) it achieves similar time lower bound than previous work proved for a much more demanding Local Broadcast where each node sends a possibly different message to each neighbor, and iv) it takes into account the local domination parameter gamma(2). 2012 ACM Subject Classification Theory of computation -> Distributed algorithms
In the Pinwheel Packing problem, we are given a set of recurring tasks, each associated with a positive integer a(i) for task i. The objective is to select one task to perform each day such that every task i is performed at least once within every a(i) consecutive days. The exact computational complexity of this problem, where Sigma 1/ a(i) = 1, has remained an open question for more than 30 years; in particular, it is still unknown whether the problem is NP-hard. The first contribution of this paper is to show that Pinwheel Packing cannot be solved in polynomial time under a standard complexity assumption, improving upon the hardness result shown by Jacobs and Longo. Additionally, we present fixed-parameter algorithms for variants of Pinwheel Packing, parameterized by the number of tasks. 2012 ACM Subject Classification Theory of computation -> Design and analysis of algorithms; Theory of computation -> Computational complexity and cryptography
We study the online service with deadlines (or delays) problem, in which a server must serve requests for points in a metric space while balancing travel distance and promptness of service. While the problem has been extensively studied (STOC 2017), (FOCS 2019), (FOCS 2023), the main open question whether a constant competitive ratio can be achieved remains wide open. We prove a logarithmic lower bound for a natural class of algorithms already on uniform line metrics. Our lower bound applies to, and is tight for, the best known algorithms for general metrics and uniform line metrics. 2012 ACM Subject Classification Theory of computation -> Online algorithms; Theory of computation -> K-server algorithms
Let P be a polygonal curve with n vertices in the plane. We construct a data structure of size O( n log n) suited for simplification queries of the following kind. Given a query line l and an integer k >= 1, find a curve Q on l with at most k vertices that minimizes the discrete Frechet distance to P, among all such curves. Using our data structure, a query can be handled in O(k(2) log(3) n + k log(4) n) time. More generally, a geometric tree T on n vertices in the plane can be preprocessed into a nearlinear-size structure so that, given a pair u, v of its vertices, a line l, and an integer k >= 1, one can find a curve Q on l with at most k vertices that minimizes the discrete Frechet distance to the path from u to v in T, in time O(k(2) polylog n). For the general dimension-reduction problem, where P is a curve in R-d ( d >= 3), 0 < epsilon(0) < 1 is a real parameter, and a query specifies a g-flat h (1 = g = d - 1) and an integer k >= 1, we construct a data structure of size O( n log n + f(epsilon(0))n), where f(epsilon(0)) = (1 + 1/epsilon(0))(( d-1)/2), that allows us to find a curve Q on h with at most k vertices, whose discrete Frechet distance to P is at most 1 + epsilon(0) times the distance of Q(*) to P, where Q(*) is such a curve that minimizes the distance to P. The query handling time is O(f(epsilon(0))k(2) log(2) n). 2012 ACM Subject Classification Theory of computation ->. Computational geometry
Let B be a collection of n arbitrary balls in R-3, and let G(0)(B) be their intersection graph. We provide an algorithm for performing BFS on G(0)(B), which runs in O*(n(4/3)) time, where the O *( center dot) notation hides subpolynomial factors. For r >= 0, let G(gamma)(B) be the intersection graph of the set B-gamma = {B + gamma | B is an element of B}, where B + gamma is the ball concentric with B whose radius is larger by gamma than the radius of B. We provide an efficient algorithm for the reverse shortest path (RSP) problem, where we are given two designated balls B-s, B-t of B and a parameter 0 < lambda < n, and seek the smallest value gamma* for which G(gamma)* (B) contains a path from B-s to B-t of at most lambda edges. For the special case of congruent balls (equivalently, for points in R-3), the algorithm runs in O*(n(29/21)) approximate to O*(n(1.381)) time. For the general case, the algorithm runs in O*(n(56/39)) approximate to O*(n(1.436)) time. We also extend the technique to handle other measures of expansion and higher dimensions. 2012 ACM Subject Classification Theory of computation -> Computational geometry
Over the last few years, graph-based approaches to nearest neighbor search have attracted renewed interest. Algorithms such as HNSW, NSG, and DiskANN have become popular tools in practice. These algorithms are highly versatile and come with efficient implementations. At the same time, their correctness, performance guarantees, and functionality remain poorly understood. In this talk, I will discuss the challenges and opportunities presented by this class of algorithms. 2012 ACM Subject Classification Theory of computation
In this paper, we study the problem of efficiently reporting all intersections between a given set of line segments in the plane and a query circle, focusing on the case where the segments form the edges of a connected geometric graph. While previous data structures for circle-segment intersection queries on general segment sets incur high space or query time costs, we exploit the connectivity of the input to obtain significantly improved performance. In fact, we propose a new circle-segment intersection data structure that can be constructed in O((n+ C) log(3) n) time and space on connected graphs with n edges and C edge crossings. It answers intersection queries in O( k log(3) n) time, where k denotes the output size. Our method relies on the construction of efficient circle-graph intersection oracles as well as a novel linear-time algorithm to partition the edges of the graph into balanced, connected components, which might be of independent interest. In a proof-of-concept experimental study on real-world road networks, we show that our novel data structure also performs well in practice. Even on networks with millions of edges, the construction time is within minutes and queries are answered in a few milliseconds. 2012 ACM Subject Classification Theory of computation -> Computational geometry; Theory of computation -> Data structures design and analysis
Given a set of n points in d-dimensional space, each assigned a positive weight, we study the problem of finding k axis-parallel unit hypercubes that maximize the total weight of the points contained in their union. In this paper, we present both exact and (1 - epsilon)-approximation algorithms for the case of k = 2. We present an exact algorithm that runs in O(n(2)) time in the plane, improving the previous O(n(2) log(2) n)-time result. This algorithm generalizes to higher dimensions and larger k in O( n(dk/2)) time for fixed d and k. We also present a (1 - epsilon)-approximation algorithm that runs in O( n log min{n, 1/ epsilon} + 1/epsilon(3)) time for k = 2 in the plane, improving the best known result. Our approximation algorithm also extends to higher dimensions. 2012 ACM Subject Classification Theory of computation -> Computational geometry
Timely delivery and optimal routing remain fundamental challenges in the modern logistics industry. Building on prior work that considers single-package delivery across networks using multiple types of collaborative agents with restricted movement areas (e.g., drones or trucks), we examine the complexity of the problem under structural and operational constraints. Our focus is on minimizing total delivery time by coordinating agents that differ in speed and movement range across a graph. This problem formulation aligns with the recently proposed Drone Delivery Problem with respect to delivery time (DDT), introduced by Erlebach et al. [ISAAC 2022]. We first resolve an open question posed by Erlebach et al. [ISAAC 2022] by showing that even when the delivery network is a path graph, DDT admits no polynomial-time approximation within any polynomially encodable factor a(n), unless P=NP. Additionally, we identify the intersection graph of the agents, where nodes represent agents and edges indicate an overlap of the movement areas of two agents, as an important structural concept. For path graphs, we show that DDT becomes tractable when parameterized by the treewidth w of the intersection graph, and we present an exact FPT algorithm with running time f(w) center dot poly( n, k), for some computable function f. For general graphs, we give an FPT algorithm with running time f(triangle, w) center dot poly( n, k), where triangle is the maximum degree of the intersection graph. In the special case where the intersection graph is a tree, we provide a simple polynomial-time algorithm. 2012 ACM Subject Classification Theory of computation -> Fixed parameter tractability; Theory of computation -> Graph algorithms analysis
We consider the problem of enumerating the irreducible closed sets of a closure system given by an implicational base. To date, the complexity status of this problem is widely open, and it is further known to generalize the notorious hypergraph dualization problem, even in the case of acyclic convex geometries, i.e., closure systems admitting an acyclic implicational base. This paper studies this case with a focus on the degree, which corresponds to the maximal number of implications in which an element occurs. We show that the problem is tractable for bounded values of this parameter, even when relaxed to the notions of premise- and conclusion-degree. Our algorithms rely on a sequential approach leveraging from acyclicity, combined with the solution graph traversal technique for the case of premise-degree. They are shown to perform in incremental-polynomial time. These results are complemented in the long version of this document by showing that the dual problem of constructing the implicational base can be solved in polynomial time. Finally, we argue that our running times cannot be improved to polynomial delay using the standard framework of flashlight search. 2012 ACM Subject Classification Mathematics of computing -> Enumeration
Randomized algorithms are often enjoyed for their simplicity, but the hash functions employed to yield the desired probabilistic guarantees are often too complicated to be practical. Hash functions are used everywhere in computing, e.g., hash tables, sketching, dimensionality reduction, sampling, and estimation. Many of these applications are relevant to Machine Learning, where we are often interested in similarity between high dimensional objects. Reducing the dimensionality is key to efficient processing. Abstractly, we like to think of hashing as fully-random hashing, assigning independent hash values to every possible key, but essentially this requires us to store the hash values for all keys, which is unrealistic for most key universes, e.g., 64-bit keys. In practice we have to settle for implementable hash functions, and often practitioners settle for implementations that are too simple in that the algorithms end up working only for sufficiently random input. However, the real world is full of structured/non-random input. The issue is severe, for simplistic hash functions will often work very well in tests with random input. Moreover, the issue is often that error events that should never happen in practice, happen with way too high probability. This does not show in a few tests, but will show up over time when you put the system into production. Over the last decade there has been major developments in simple to implement tabulation based hash functions offering strong theoretical guarantees, so as to support fundamental properties such as Chernoff bounds, Sparse Johnson-Lindenstrauss transforms, and fully-random hashing on a given set w.h.p. etc. I will discuss some of the principles of these developments and offer insights on how far we can bridge from theory (assuming fully-random hash functions) to practice (needing something that can actually implemented efficiently). 2012 ACM Subject Classification Theory of computation
In this paper, we study the Achromatic Number problem. Given a graph G and an integer k, the task is to determine whether there exists a proper coloring of G, using at least k colors, in which every pair of distinct colors appears on the endpoints of some edge. It was established early on that the problem is fixed-parameter tractable (FPT)- even before the formal development of parameterized complexity. In fact, Farber, Hahn, Hell, and Miller [JCTB, 1986] devised an algorithm with a running time of O(f(k) center dot |E(G)|). Although the exact form of f(k) was not specified, it appears to be at least doubly exponential in k. In our work, we first present an algorithm with an explicit dependence on k, and then introduce another algorithm that is parameterized by the vertex cover number of the graph. More formally, we show the following. Achromatic Number is solvable in time 2(O(k5)) + O(|E(G)|). Achromatic Number admits a polynomial kernel when the input is restricted to a d-degenerate graph and a more efficient kernel on trees. We also study the parameterized complexity of the problem with respect to Vertex Cover and show that it admits an FPT algorithm running in time 2(O(l2)) center dot n(O(1)), where l is the size of a vertex cover. 2012 ACM Subject Classification Theory of computation -> Fixed parameter tractability
Given a set of graphs on the same vertex set, the problem Simultaneous Embedding With Fixed Edges (SEFE) asks, whether there exist planar drawings of all input graphs, such that every pair of drawings coincides on their shared subgraph. It is known that SEFE is NP-complete [32], even in the so-called sunflower case, where all pairs of input graphs have the same shared graph G(boolean AND) [57]. Fink, Pfretzschner, and Rutter [26] recently initiated the study of the parameterized complexity of SEFE in the sunflower case, mainly focusing on structural parameters of G(boolean AND). In this work, we shift the focus towards parameters of the union graph G(boolean OR) that contains the edges of all input graphs. On the positive side, we establish fixed-parameter tractability for the problem with respect to the feedback edge set number of G(boolean OR). We complement this result by showing that it, surprisingly, remains NP-complete even if G(boolean OR) has constant vertex cover number. These results settle two open questions posed by Fink et al. [26]. 2012 ACM Subject Classification Mathematics of computing -> Graph algorithms
We derive an improved upper bound for the number of incidences between the n vertices of a uniform grid and m convex or concave curves, each pair of which intersect in at most s points, for some integer parameter s >= 1. For a square grid, our bound is O (n(2/3) m(2/3) + m(1- 1/3s) n(s+1/3s) + m + n). This improves a general bound of O(mn(1/3)) on the number of incidences with respect to vertices of a grid and convex or concave curves. For a rectangular grid, which fits inside a 1 x K rectangle, for some integer K > 1 (which generally may depend on n), the bound also depends on how large K is. The precise result is stated in Theorem 2, but, roughly, we get the same bound as above when K is not too large. Our analysis competes with a celebrated result of Bombieri and Pila [6], which gives (usually) a sharper bound if we assume that the input curves are algebraic of constant degree and the input points are vertices of the square grid. However, the analysis in [6] strongly relies on these assumptions, and cannot be extended to handle the more general setup considered here. As a main application, of independent interest, we present a variant of our technique for semi-algebraic range reporting on sets of points of "bounded spread" in the plane. 2012 ACM Subject Classification Theory of computation; Theory of computation -> Computational geometry
Online bipartite matching is a classical problem in online algorithms and we know that both the deterministic fractional and randomized integral online matchings achieve the same competitive ratio of 1 - 1/e. In this work, we study classes of graphs where the online degree is restricted to 2. As expected, one can achieve a competitive ratio of better than 1 - 1/e in both the deterministic fractional and randomized integral cases, but surprisingly, these ratios are not the same. It was already known that for fractional matching, a 0.75 competitive ratio algorithm is optimal. We show that the folklore Half-Half algorithm achieves a competitive ratio of eta approximate to 0.717772... and more surprisingly, show that this is optimal by giving a matching lower-bound. This yields a separation between the two problems: deterministic fractional and randomized integral, showing that it is impossible to obtain a perfect rounding scheme. 2012 ACM Subject Classification Theory of computation. Online algorithms
A drawing of a graph is 1-planar if each edge participates in at most one crossing and adjacent edges do not cross. Up to symmetry, each crossing in a 1-planar drawing belongs to one out of six possible crossing types, where a type characterizes the subgraph induced by the four vertices of the crossing edges. Each of the 63 possible nonempty subsets S of crossing types gives a recognition problem: does a given graph admit an S-restricted drawing, that is, a 1-planar drawing where the crossing type of each crossing is in S? We show that there is a set S-bad with three crossing types and the following properties: If S contains no crossing type from S-bad, then the recognition of graphs that admit an S-restricted drawing is fixed-parameter tractable with respect to the treewidth of the input graph. If S contains any crossing type from S-bad, then it is NP-hard to decide whether a graph has an S-restricted drawing, even when considering graphs of constant pathwidth. We also extend this characterization of crossing types to 1-planar straight-line drawings and show the same complexity behaviour parameterized by treewidth. 2012 ACM Subject Classification Theory of computation -> Design and analysis of algorithms; Theory of computation -> Fixed parameter tractability
In the Coloring Reconfiguration problem, we are given two proper k-colorings of a graph and asked to decide whether one can be transformed into the other by repeatedly applying a specified recoloring rule, while maintaining a proper coloring throughout. For this problem, two recoloring rules have been widely studied: single-vertex recoloring and Kempe chain recoloring. In this paper, we introduce a new rule, called color swapping, where two adjacent vertices may exchange their colors, so that the resulting coloring remains proper, and study the computational complexity of the problem under this rule. We first establish a complexity dichotomy with respect to k: the problem is solvable in polynomial time for k <= 2, and is PSPACE-complete for k >= 3. We further show that the problem remains PSPACE-complete even on restricted graph classes, including bipartite graphs, split graphs, and planar graphs of bounded degree. In contrast, we present polynomial-time algorithms for several graph classes: for paths when k = 3, for split graphs when k is fixed, and for cographs when k is arbitrary. 2012 ACM Subject Classification Theory of computation -> Graph algorithms analysis
The Planar Separator Theorem, which states that any planar graph G has a separator consisting of O(root n) nodes whose removal partitions G into components of size at most 2n/3, is a widely used tool to obtain fast algorithms on planar graphs. Intersection graphs of disks, which generalize planar graphs, do not admit such separators. It has recently been shown that disk graphs do admit so-called clique-based separators that consist of O(root n) cliques. This result has been generalized to intersection graphs of various other types of disk-like objects. Unfortunately, segment intersection graphs do not admit small clique-based separators, because they can contain arbitrarily large bicliques. This is true even in the simple case of axis-aligned segments. In this paper we therefore introduce biclique-based separators (and, in particular, star-based separators), which are separators consisting of a small number of bicliques (or stars). We prove that any c-oriented set of n segments in the plane, where c is a constant, admits a star-based separator consisting of O(root n) stars. In fact, our result is more general, as it applies to any set of n pseudo-segments that is partitioned into c subsets such that the pseudo-segments in the same subset are pairwise disjoint. We extend our result to intersection graphs of c-oriented polygons. These results immediately lead to an almost-exact distance oracle for such intersection graphs, which has O(n root n) storage and O(root n) query time, and that can report the hop-distance between any two query nodes in the intersection graph with an additive error of at most 2. This is the first distance oracle for such types of intersection graphs that has subquadratic storage and sublinear query time and that only has an additive error. 2012 ACM Subject Classification Theory of computation -> Design and analysis of algorithms
In reconfiguration problems, we are given two feasible solutions to a graph problem and asked whether one can be transformed into the other via a sequence of feasible intermediate solutions under a given reconfiguration rule. While earlier work focused on modifying a single element at a time, recent studies have started examining how different rules impact computational complexity. Motivated by recent progress, we study Independent Set Reconfiguration (ISR) and Vertex Cover Reconfiguration (VCR) under the k-Token Jumping (k-TJ) and k-Token Sliding (k-TS) models. In k-TJ, up to k vertices may be replaced, while k-TS additionally requires a perfect matching between removed and added vertices. It is known that the complexity of ISR crucially depends on k, ranging from PSPACE-complete and NP-complete to polynomial-time solvable. In this paper, we further explore the gradient of computational complexity of the problems. We first show that ISR under k-TJ with k = |I|- mu remains NP-hard when mu is any fixed positive integer and the input graph is restricted to graphs of maximum degree 3 or planar graphs of maximum degree 4, where |I| is the size of feasible solutions. In addition, we prove that the problem belongs to NP not only for mu = O(1) but also for mu = O(log |I|). In contrast, we show that VCR under k-TJ is in XP when parameterized by mu = |S| - k, where |S| is the size of feasible solutions. Furthermore, we establish the PSPACE-completeness of ISR and VCR under both k-TJ and k-TS on several graph classes, for fixed k as well as superconstant k relative to the size of feasible solutions. 2012 ACM Subject Classification Theory of computation -> Graph algorithms analysis; Theory of computation -> Problems, reductions and completeness
Balanced search trees are widely used in computer science to efficiently maintain dynamic ordered data. To support efficient set operations (e.g., union, intersection, difference) using trees, the join-based framework is widely studied. This framework has received particular attention in the parallel setting, and has been shown to be effective in enabling simple and theoretically efficient set operations on trees. Despite the widespread adoption of parallel join-based trees, a major drawback of previous work on such data structures is the inefficiency of their input/output (I/O) access patterns. Some recent work (e.g., C-trees and PaC-trees) focused on more I/O-friendly implementations of these algorithms. Surprisingly, however, there have been no results on bounding the I/O-costs for these algorithms. It remains open whether these algorithms can provide tight, provable guarantees in I/O-costs on trees. This paper studies efficient parallel algorithms for set operations based on search tree algorithms using a join-based framework, with a special focus on achieving I/O efficiency in these algorithms. To better capture the I/O-efficiency in these algorithms in parallel, we introduce a new computational model, the Fork-Join I/O Model, to measure the I/O costs in fork-join parallelism. This model measures the total block transfers (I/O work) and their critical path (I/O span). Under this model, we propose our new solution based on B-trees. Our parallel algorithm computes the union, intersection, and difference of two B-trees with O(m log(B)( n/m)) I/O work and O(log(B) m center dot log(2) log(B) n + log(B) n) I/O span, where n and m <= n are the sizes of the two trees, and B is the block size. 2012 ACM Subject Classification Computing methodologies -> Massively parallel algorithms
