ACM Transactions on Algorithms最新文献

In this article, we provide a unified and simplified approach to derandomize central results in the area of fault-tolerant graph algorithms. Given a graph (G), a vertex pair ((s,t)in V(G)times V(G)), and a set of edge faults (Fsubseteq E(G)), a replacement path (P(s,t,F)) is an (s)-(t) shortest path in (Gsetminus F). For integer parameters (L,f), a replacement path covering (RPC) is a collection of subgraphs of (G), denoted by (mathcal{G}_{L,f}={G_{1},ldots,G_{r}}), such that for every set (F) of at most (f) faults (i.e., (|F|leq f)) and every replacement path (P(s,t,F)) of at most (L) edges, there exists a subgraph (G_{i}inmathcal{G}_{L,f}) that contains all the edges of (P) and does not contain any of the edges of (F). The covering value of the RPC (mathcal{G}_{L,f}) is then defined to be the number of subgraphs in (mathcal{G}_{L,f}).

In the randomized setting, it is easy to build an ((L,f))-RPC with covering value of (O(max{L,f}^{min{L,f}}cdotmin{L,f}cdotlog n)), but to this date, there is no efficient deterministic algorithm with matching bounds. As noted recently by Alon, Chechik, and Cohen (ICALP 2019) this poses the key barrier for derandomizing known constructions of distance sensitivity oracles and fault-tolerant spanners. We show the following:

• There exist efficient deterministic constructions of ((L,f))-RPCs whose covering values almost match the randomized ones, for a wide range of parameters. Our time and value bounds improve considerably over the previous construction of Parter (DISC 2019). Our algorithms are based on the introduction of a novel notion of hash families that we call Hit and Miss hash families. We then show how to construct these hash families from (algebraic) error correcting codes such as Reed-Solomon codes and Algebraic-Geometric codes.

• For every (L,f), and (n), there exists an (n)-vertex graph (G) whose ((L,f))-RPC covering value is (Omega(L^{f})). This lower bound is obtained by exploiting connections to the problem of designing sparse fault-tolerant BFS structures.

An application of our above deterministic constructions is the derandomization of the algebraic construction of the distance sensitivity oracle by Weimann and Yuster (FOCS 2010). The preprocessing and query time of our deterministic algorithm nearly match the randomized bounds. This resolves the open problem of Alon, Chechik and Cohen (ICALP 2019).

Additionally, we show a derandomization of the randomized construction of vertex fault-tolerant spanners by Dinitz and Krauthgamer (PODC 2011) and Braunschvig et al. (Theor. Comput. Sci., 2015). The time complexity and the size bounds of the output spanners nearly match the randomized counterparts.

The complexity of the promise constraint satisfaction problem (operatorname{PCSP}(mathbf{A},mathbf{B})) is largely unknown, even for symmetric (mathbf{A}) and (mathbf{B}), except for the case when (mathbf{A}) and (mathbf{B}) are Boolean.

First, we establish a dichotomy for (operatorname{PCSP}(mathbf{A},mathbf{B})) where (mathbf{A},mathbf{B}) are symmetric, (mathbf{B}) is functional (i.e. any (r-1) elements of an (r)-ary tuple uniquely determines the last one), and ((mathbf{A},mathbf{B})) satisfies technical conditions we introduce called dependency and additivity. This result implies a dichotomy for (operatorname{PCSP}(mathbf{A},mathbf{B})) with (mathbf{A},mathbf{B}) symmetric and (mathbf{B}) functional if (i) (mathbf{A}) is Boolean, or (ii) (mathbf{A}) is a hypergraph of a small uniformity, or (iii) (mathbf{A}) has a relation (R^{mathbf{A}}) of arity at least 3 such that the hypergraph diameter of ((A,R^{mathbf{A}})) is at most 1.

Second, we show that for (operatorname{PCSP}(mathbf{A},mathbf{B})), where (mathbf{A}) and (mathbf{B}) contain a single relation, (mathbf{A}) satisfies a technical condition called balancedness, and (mathbf{B}) is arbitrary, the combined basic linear programming relaxation ((operatorname{BLP})) and the affine integer programming relaxation ((operatorname{AIP})) is no more powerful than the (in general strictly weaker) (operatorname{AIP}) relaxation. Balanced (mathbf{A}) include symmetric (mathbf{A}) or, more generally, (mathbf{A}) preserved by a transitive permutation group.

A partition (mathcal{P}) of a weighted graph (G) is ((sigma,tau,Delta))-sparse if every cluster has diameter at most (Delta), and every ball of radius (Delta/sigma) intersects at most (tau) clusters. Similarly, (mathcal{P}) is ((sigma,tau,Delta))-scattering if instead for balls we require that every shortest path of length at most (Delta/sigma) intersects at most (tau) clusters. Given a graph (G) that admits a ((sigma,tau,Delta))-sparse partition for all (Delta gt 0), Jia et al. [STOC05] constructed a solution for the Universal Steiner Tree problem (and also Universal TSP) with stretch (O(tausigma^{2}log_{tau}n)). Given a graph (G) that admits a ((sigma,tau,Delta))-scattering partition for all (Delta gt 0), we construct a solution for the Steiner Point Removal problem with stretch (O(tau^{3}sigma^{3})). We then construct sparse and scattering partitions for various different graph families, receiving many new results for the Universal Steiner Tree and Steiner Point Removal problems.

Longest Common Substring (LCS) is an important text processing problem, which has recently been investigated in the quantum query model. The decision version of this problem, LCS with threshold (d), asks whether two length-(n) input strings have a common substring of length (d). The two extreme cases, (d=1) and (d=n), correspond respectively to Element Distinctness and Unstructured Search, two fundamental problems in quantum query complexity. However, the intermediate case (1ll dll n) was not fully understood.

We show that the complexity of LCS with threshold (d) smoothly interpolates between the two extreme cases up to (n^{o(1)}) factors:

• LCS with threshold (d) has a quantum algorithm in (n^{2/3+o(1)}/d^{1/6}) query complexity and time complexity, and requires at least (Omega(n^{2/3}/d^{1/6})) quantum query complexity.

Our result improves upon previous upper bounds (tilde{O}(min{n/d^{1/2},n^{2/3}})) (Le Gall and Seddighin ITCS 2022, Akmal and Jin SODA 2022), and answers an open question of Akmal and Jin.

Our main technical contribution is a quantum speed-up of the powerful String Synchronizing Set technique introduced by Kempa and Kociumaka (STOC 2019). It consistently samples (n/tau^{1-o(1)}) synchronizing positions in the string depending on their length-(Theta(tau)) contexts, and each synchronizing position can be reported by a quantum algorithm in (tilde{O}(tau^{1/2+o(1)})) time. Our quantum string synchronizing set also yields a near-optimal LCE data structure in the quantum setting.

As another application of our quantum string synchronizing set, we study the (k)-mismatch Matching problem, which asks if the pattern has an occurrence in the text with at most (k) Hamming mismatches. Using a structural result of Charalampopoulos, Kociumaka, and Wellnitz (FOCS 2020), we obtain:

• (k)-mismatch matching has a quantum algorithm with (k^{3/4}n^{1/2+o(1)}) query complexity and (tilde{O}(kn^{1/2})) time complexity. We also observe a non-matching quantum query lower bound of (Omega(sqrt{kn})).

The Fréchet distance is a popular measure of dissimilarity for polygonal curves. It is defined as a min-max formulation that considers all orientation-preserving bijective mappings between the two curves. Because of its susceptibility to noise, Driemel and Har-Peled introduced the shortcut Fréchet distance in 2012, where one is allowed to take shortcuts along one of the curves, similar to the edit distance for sequences. We analyse the parameterized version of this problem, where the number of shortcuts is bounded by a parameter (k). The corresponding decision problem can be stated as follows: Given two polygonal curves (T) and (B) of at most (n) vertices, a parameter (k) and a distance threshold (delta), is it possible to introduce (k) shortcuts along (B) such that the Fréchet distance of the resulting curve and the curve (T) is at most (delta)? We study this problem for polygonal curves in the plane. We provide a complexity analysis for this problem with the following results: (i) there exists a decision algorithm with running time in (mathcal{O}(kn^{2k+2}log n)); (ii) assuming the exponential-time-hypothesis (ETH), there exists no algorithm with running time bounded by (n^{o(k)}). In contrast, we also show that efficient approximate decider algorithms are possible, even when (k) is large. We present a ((3+varepsilon))-approximate decider algorithm with running time in (mathcal{O}(kn^{2}log^{2}n)) for fixed (varepsilon). In addition, we can show that, if (k) is a constant and the two curves are (c)-packed for some constant (c), then the approximate decider algorithm runs in near-linear time.

We present a new sorting algorithm, called adaptive ShiversSort, that exploits the existence of monotonic runs for sorting efficiently partially sorted data. This algorithm is a variant of the well-known algorithm TimSort, which is the sorting algorithm used in standard libraries of programming languages such as Python or Java (for non-primitive types). More precisely, adaptive ShiversSort is a so-called (k)-aware merge-sort algorithm, a class that captures “TimSort-like” algorithms and that was introduced by Buss and Knop.

In this article, we prove that, although adaptive ShiversSort is simple to implement and differs only slightly from TimSort, its computational cost, in number of comparisons performed, is optimal within the class of natural merge-sort algorithms, up to a small additive linear term. This makes adaptive ShiversSort the first (k)-aware algorithm to benefit from this property, which is also a 33% improvement over TimSort’s worst-case. This suggests that adaptive ShiversSort could be a strong contender for being used instead of TimSort.

Then, we investigate the optimality of (k)-aware algorithms. We give lower and upper bounds on the best approximation factors of such algorithms, compared to optimal stable natural merge-sort algorithms. In particular, we design generalisations of adaptive ShiversSort whose computational costs are optimal up to arbitrarily small multiplicative factors.

No abstract available.

We consider a generalization of the Steiner tree problem, the Steiner forest problem, in the Euclidean plane: the input is a multiset (Xsubseteq{mathbb{R}}^{2}), partitioned into (k) color classes (C_{1},ldots,C_{k}subseteq X). The goal is to find a minimum-cost Euclidean graph (G) such that every color class (C_{i}) is connected in (G). We study this Steiner forest problem in the streaming setting, where the stream consists of insertions and deletions of points to (X). Each input point (xin X) arrives with its color (mathsf{color}(x)in[k]), and as usual for dynamic geometric streams, the input is restricted to the discrete grid ({1,ldots,Delta}^{2}).

We design a single-pass streaming algorithm that uses (operatorname{poly}(kcdotlogDelta)) space and time, and estimates the cost of an optimal Steiner forest solution within ratio arbitrarily close to the famous Euclidean Steiner ratio (alpha_{2}) (currently (1.1547leqalpha_{2}leq 1.214)). This approximation guarantee matches the state-of-the-art bound for streaming Steiner tree, i.e., when (k=1), and it is a major open question to improve the ratio to (1+varepsilon) even for this special case. Our approach relies on a novel combination of streaming techniques, like sampling and linear sketching, with the classical Arora-style dynamic-programming framework for geometric optimization problems, which usually requires large memory and so far has not been applied in the streaming setting.

We complement our streaming algorithm for the Steiner forest problem with simple arguments showing that any finite multiplicative approximation requires (Omega(k)) bits of space.

We introduce and analyse an efficient decoder for quantum Tanner codes that can correct adversarial errors of linear weight. Previous decoders for quantum low-density parity-check codes could only handle adversarial errors of weight (O(sqrt{nlog n})). We also work on the link between quantum Tanner codes and the Lifted Product codes of Panteleev and Kalachev, and show that our decoder can be adapted to the latter. The decoding algorithm alternates between sequential and parallel procedures and converges in linear time.

We prove a structural theorem for unit-disk graphs, which (roughly) states that given a set (mathcal{D}) of (n) unit disks inducing a unit-disk graph (G_{mathcal{D}}) and a number (pin[n]), one can partition (mathcal{D}) into (p) subsets (mathcal{D}_{1},dots,mathcal{D}_{p}) such that for every (iin[p]) and every (mathcal{D}^{prime}subseteqmathcal{D}_{i}), the graph obtained from (G_{mathcal{D}}) by contracting all edges between the vertices in (mathcal{D}_{i}backslashmathcal{D}^{prime}) admits a tree decomposition in which each bag consists of (O(p+|mathcal{D}^{prime}|)) cliques. Our theorem can be viewed as an analog for unit-disk graphs of the structural theorems for planar graphs and almost-embeddable graphs proved recently by Marx et al. [SODA’22] and Bandyapadhyay et al. [SODA’22].

By applying our structural theorem, we give several new combinatorial and algorithmic results for unit-disk graphs. On the combinatorial side, we obtain the first Contraction Decomposition Theorem (CDT) for unit-disk graphs, resolving an open question in the work by Panolan et al. [SODA’19]. On the algorithmic side, we obtain a new algorithm for bipartization (also known as odd cycle transversal) on unit-disk graphs, which runs in (2^{O(sqrt{k}log k)}cdot n^{O(1)}) time, where (k) denotes the solution size. Our algorithm significantly improves the previous slightly subexponential-time algorithm given by Lokshtanov et al. [SODA’22] which runs in (2^{O(k^{27/28})}cdot n^{O(1)}) time. We also show that the problem cannot be solved in (2^{o(sqrt{k})}cdot n^{O(1)}) time assuming the ETH, which implies that our algorithm is almost optimal.