cs.DS — Pith

0

cs.DS 2026-05-14 Recognition

Graph doubling maps ultrabubbles to weak superbubbles in linear time

The Power of Graph Doubling: Computing Ultrabubbles in a Bidirected Graph by Reducing to Weak Superbubbles

The construction lets existing directed-graph algorithms compute these nested structures on any bidirected graph without new code.

abstract click to expand

Bidirected graphs are a common generalisation of directed graphs where arcs can also be incoming to both their incident nodes, or outgoing from both their incident nodes. Such arcs allow a walk to change direction. Some algorithms can easily be adapted from directed graphs to bidirected graphs, such as shortest path algorithms. These adaptions are already used in practice, and implicitly use the graph doubling technique to apply an algorithm for directed graphs to bidirected graphs. In other cases, the applicability of graph doubling is not that obvious. For example, superbubbles and their generalisation to bidirected graphs ultrabubbles. Ultrabubbles are a common structure in bidirected biological graphs which carries biological meaning, but also functions as a nested clustering method, since an ultrabubble is separated by only two nodes from the rest of the graph. There is an existing method that enumerates a structure similar to ultrabubbles by enumerating (weak) superbubbles in the doubled graph. However, the literature does not make any direct connection between superbubbles and ultrabubbles except that a superbubble is an ultrabubble in a directed graph. Only a partial result connecting superbubbles and ultrabubbles exists by Harviainen et al. (2026). Graph doubling on the other hand maintains connectivity, and allows to draw a direct connection between ultrabubbles and weak superbubbles. This results in the first linear-time reduction-based algorithm for computing ultrabubbles on any bidirected graph. Together with the fact that graph doubling is already used implicitly in simple cases, our result motivates that graph doubling is a powerful yet simple technique to apply algorithms for directed graphs to bidirected graphs.

0

cs.DS 2026-05-13 2 theorems

BFS width plus few backward arcs yields FPT for PAFP

Layer-Based Width for PAFP

Union digraph layering enables tractability even with unrestricted forbidden pairs and exponentially many paths.

abstract click to expand

The Path Avoiding Forbidden Pairs problem (PAFP) asks whether, in a directed graph $G$ with terminals $s,t$ and a set $\mathcal{F}$ of forbidden vertex pairs, there is an $s$-$t$ path that contains at most one endpoint from each forbidden pair. We initiate the study of PAFP through a layer-based width measure. Our first focus is the union digraph $G\cup\mathcal{F}$, obtained by adding to $G$ one arc per forbidden pair, oriented according to a fixed reachability-compatible order. Let the BFS layer $L_d$ be all vertices at directed shortest-path distance $d$ from $s$, where the BFS-width from $s$ is $\max_d |L_d|$. We show if $G\cup\mathcal{F}$ has BFS-width $b$ from $s$ and only $\beta$ arcs going from a later BFS layer to an earlier one, then PAFP is FPT parameterized by $b+\beta$. The backward-arc hypothesis is essential: we show PAFP remains NP-complete when the union digraph is a DAG with BFS-width 2. We also show if the input DAG has BFS-width at most $2$ and only $k$ backward input arcs, then PAFP can be decided in $2^k |I|^{O(1)}$ time, with unrestricted forbidden pairs. This width-$2$ result is tight: inspection of a classical reduction shows NP-completeness on input DAGs of BFS-width $3$ with no backward input arcs. Moreover, we study exact-length layers in the input graph, where the $d$-th layer consists of the vertices reachable from $s$ by a directed path of length exactly $d$. For DAGs of exact-length width at most $2$, we show PAFP is polynomial-time decidable by a 2-SAT encoding of fixed-length paths. This bound is tight: the same classical reduction yields NP-completeness on DAGs of exact-length width $3$. Unlike previously known polynomial-time regimes for PAFP, which restrict the forbidden-pair set in order to obtain tractability, our two input-graph tractability results allow unrestricted forbidden pairs and input graphs with exponentially many $s$-$t$ paths.

0

cs.DS 2026-05-13 Recognition

Ulam similarity admits O(n/sqrt(log n)) LSH distortion

On the LSH Distortion of Ulam and Cayley Similarities

Lower bound Omega(n^0.12) for Ulam; Cayley similarity requires Theta(n) distortion, showing when hashing works for permutation nearest-neigh

abstract click to expand

Locality-sensitive hashing (LSH) has found widespread use as a fundamental primitive, particularly to accelerate nearest neighbor search. An LSH scheme for a similarity function $S:\mathcal{X} \times \mathcal{X} \to [0,1]$ is a distribution over hash functions on $\mathcal{X}$ with the property that the probability of collision of any two elements $x,y\in \mathcal{X}$ is exactly equal to $S(x,y)$. However, not all similarity functions admit exact LSH schemes. The notion of LSH distortion measures how multiplicatively close a similarity function is to having an LSH scheme. In this work, we study the LSH distortion of the Ulam and Cayley similarities, which are popular similarity measures on permutations of $n$ elements. We show that the Ulam similarity admits a sublinear LSH distortion of $O(n / \sqrt{\log n})$; we also prove a lower bound of $\Omega(n^{0.12})$ on the best LSH distortion achievable. On the other hand, we show that the LSH distortion of the Cayley similarity is $\Theta(n)$.

0

cs.DS 2026-05-13 2 theorems

k-path temporal graphs allow FPT reachability via label shifts

Maximizing Reachability via Shifting of Temporal Paths

The problem remains tractable for any number of shifts when only the number of paths is the parameter.

abstract click to expand

We examine the problem of maximizing the reachability of a given source in temporal graphs that are given as the union of k temporal paths, i.e., every given path is a sequence of edges with strictly increasing labels that denote availability in time. This type of temporal graphs represent train networks. We consider shifting operations on the labels of the paths that maintain their temporal continuity. This means that we can move the availability of a temporal edge later or earlier in time, and propagate the shifts to all other affected edges of the path in order to preserve its temporal connectivity. We study the parameterized complexity of the problem with respect to the number of paths k, and the total budget b, where b is the maximum number of shifts we are allowed to perform. Our results reveal that fixed parameter tractability can be achieved (1) when parameterized both by k and b, and (2) when parameterized by k, and b is unconstrained. In almost every other case, e.g., parameterized by a single parameter or parameterized by k, while having a bound on b, we establish intractability lower bounds that are matched by XP algorithms.

0

cs.DS 2026-05-13 Recognition

Vertex connectivity augmentation is FPT in λ and k

Connectivity augmentation is fixed-parameter tractable

New algorithms run in time 2 to the O of k log of k plus λ times n to the O of 1, removing the prior limit of λ at most 4.

abstract click to expand

In the vertex connectivity augmentation problem, we are given an undirected $n$-vertex graph $G$, a set of links $L \subseteq \binom{V(G)}{2} \setminus E(G)$, and integers $\lambda$ and $k$. The task is to insert at most $k$ links from $L$ to $G$ to make $G$ $\lambda$-vertex-connected. We show that the problem is fixed-parameter tractable (FPT) when parameterized by $\lambda$ and $k$, by giving an algorithm with running time $2^{O(k \log (k + \lambda))} n^{O(1)}$. This improves upon a recent result of Carmesin and Ramanujan [SODA'26], who showed that the problem is FPT parameterized by $k$ but only when $\lambda \le 4$. We also consider the analogous edge connectivity augmentation problem, where the goal is to make $G$ $\lambda$-edge-connected. We show that the problem is FPT when parameterized by $k$ only, by giving an algorithm with running time $2^{O(k \log k)} n^{O(1)}$. Previously, such results were known only under additional assumptions on the edge connectivity of $G$.

0

cs.DS 2026-05-12 2 theorems

k-d trees reduce nearest neighbor search to random guessing in high dimensions

Performance bounds for nearest neighbor search with k-d trees

When dimension grows polylogarithmically with data points, defeatist search matches chance level and comprehensive search checks every cell

abstract click to expand

The $k$-d tree is one of the oldest and most widely used data structures for nearest neighbor search. It partitions Euclidean space into axis-aligned rectangular cells. There are two standard ways to find the nearest neighbor to a query in a $k$-d tree. Defeatist search returns the closest data point in the query's cell, while comprehensive search also searches other cells as needed to guarantee it finds the nearest neighbor. Both strategies are commonly believed to perform poorly in high dimensions, but there have been few theoretical results explaining this. We prove non-asymptotic bounds on the runtime of comprehensive search and the accuracy of defeatist search. Under mild distributional assumptions, when the dimension $d$ is at least polylogarithmic in the number of data points, defeatist search is no more likely to return the nearest neighbor than random guessing, and comprehensive search visits every cell with high probability. We also show that on uniform data, with high probability, comprehensive search visits at most $2^{\mathcal{O}(d)}$ cells when each cell contains at least logarithmically many data points, and defeatist search returns the nearest neighbor when each cell additionally contains at least $2^{\mathcal{O}(d \log d)}$ data points. Finally, for arbitrary absolutely continuous distributions, we upper bound the expected distance between the query and the point returned by defeatist search.

0

cs.DS 2026-05-12 Recognition

Generalized doubling gives optimal O(2^k) ratio for k-set chasing

Chasing Small Sets Optimally Against Adaptive Adversaries

Closes 30-year gap and proves tightness even for randomized algorithms against adaptive adversaries

abstract click to expand

We study deterministic online algorithms for the problem of chasing sets of cardinality at most $k$ in a metric space, also known as metrical service systems and equivalent to width-$k$ layered graph traversal. We resolve the 30-year-old gap of $\Omega(2^k)\cap O(k2^k)$ on the competitive ratio of this problem by giving an $O(2^k)$-competitive deterministic algorithm. This bound is optimal even among randomized algorithms against adaptive adversaries. We also (slightly) improve the deterministic lower bound to $D_k$, defined recursively by $D_1=1$ and $D_{k+1}=2D_k+\sqrt{8+8D_k}+3$, which we conjecture to be exactly tight. For $k=3$, we provide a matching upper bound of $D_3$. Our results imply slightly improved upper and lower bounds for distributed asynchronous collective tree exploration and for the $k$-taxi problem, respectively. Our algorithm generalizes the classical doubling strategy, previously known to be optimal for $k=2$. The previous best bound for general $k$ was achieved by the generalized work function algorithm (WFA), and was known to be tight for WFA. Our improved bound therefore implies that WFA is sub-optimal for chasing small sets.

0

cs.DS 2026-05-12 Recognition

FPT schemes give (1+ε) approximations for min-sum radii and diameters

FPT Approximation Schemes for Min-Sum Radii and Min-Sum Diameters Clustering

Algorithms run in time exponential in k for any desired approximation factor, closing an open question on FPT approximation schemes.

abstract click to expand

In the classical Min-Sum Radii problem (MSR) we are given a set $X$ of $n$ points in a metric space and a positive integer $k\in [n]$. Our goal is to partition $X$ into $k$ subsets (the clusters) so as to minimize the sum of the radii of these clusters. The Min-Sum Diameters problem (MSD) is defined analogously, where instead of the radii of the clusters we consider their diameters. For both problems we present FPT approximation schemes for the natural parameter $k$. Specifically, given $\epsilon>0$, we show how to compute $(1+\epsilon)$-approximations for both MSD and MSR in time $(1/\epsilon)^kn^{O(1)}$ and $(1/\epsilon)^{O(k/\epsilon \log 1/\epsilon)}n^{poly(1/\epsilon)}$ respectively. The previous best FPT approximation algorithms for these problems have approximation factors $4+\epsilon$ and $2+\epsilon$, respectively, and finding an FPT approximation scheme for both these problems had been outstanding open problems.

0

cs.DS 2026-05-12 Recognition

Label-private convex optimization now scales as sqrt(K) excess risk

Convex Optimization with Local Label Differential Privacy: Tight Bounds in All Privacy Regimes

New non-interactive algorithm and matching lower bound replace prior linear cost on label space size for large sample sizes n.

abstract click to expand

We study the problem of Stochastic Convex Optimization (SCO) under the constraint of local Label Differential Privacy (L-LDP). In this setting, the features are considered public, but the corresponding labels are sensitive and must be randomized by each user locally before being sent to an untrusted analyzer. Prior work for SCO under L-LDP (Ghazi et al., 2021) established an excess population risk bound with a \emph{linear} dependence on the size of the label space, $K$: $O\left({\frac{K}{\epsilon\sqrt{n}}}\right)$ in the high-privacy regime ($\epsilon \leq 1$) and $O\left({\frac{K}{e^{\epsilon} \sqrt{n}}}\right)$ in the medium-privacy regime ($1 \leq \epsilon \leq \ln K$). This left open whether this linear cost is fundamental to the L-LDP model. In this note, we resolve this question. First, we present a novel and efficient non-interactive L-LDP algorithm that achieves an excess risk of $O\left({\sqrt{\frac{K}{\epsilon n}}}\right)$ in the high-privacy regime ($\epsilon \leq 1$) and $O\left({\sqrt{\frac{K}{e^{\epsilon} n}}}\right)$ in the medium-privacy regime ($1 \leq \epsilon \leq \ln K$). This quadratically improves the dependency on the label space size from $O(K)$ to $O(\sqrt{K})$. Second, we prove a matching information-theoretic lower bound across all privacy regimes for any sufficiently large $n$.

0

cs.DS 2026-05-12 Recognition

New algorithm tightens 2-vertex-connectivity approximation to 95/72 + ε

An Approximation Algorithm for 2-Vertex-Connectivity via Cycle-Restricted 2-Edge-Covers

Cycle-restricted edge covers replace the prior 4/3 guarantee for finding the cheapest set of edges that survives any single vertex failure.

abstract click to expand

In the 2-Vertex-Connected Spanning Subgraph problem (2-VCSS), we are given an undirected graph $G$, and the objective is to find a 2-vertex-connected spanning subgraph $S$ of $G$ with the minimum number of edges. In the context of survivable network design, 2-VCSS is one of the most fundamental and well-studied problems. There has been active research on improving the approximation ratio of algorithms, and the current best ratio is $\frac{4}{3}$, achieved by Bosch-Calvo, Grandoni, and Jabal Ameli. In this paper, we improve the approximation ratio to $\frac{95}{72}+\varepsilon$ ($<1.32$). The key idea in our algorithm is to introduce a 2-edge-cover without certain cycle components, and use it as an initial solution.

0

cs.DS 2026-05-12 2 theorems

Algorithm tightens GMSSC approximation to 4.509

A 4.509-Approximation Algorithm for Generalized Min Sum Set Cover

Improved LP analysis and new Bernoulli tail bounds reduce the ratio from 4.642 toward the hardness threshold of 4.

abstract click to expand

We study the \emph{generalized min-sum set cover} (GMSSC) problem, where given a collection of hyperedges $E$ with arbitrary covering requirements $\{k_e \in \mathbb{Z}^+ : e \in E\}$, the objective is to find an ordering of the vertices that minimizes the total cover time of the hyperedges. A hyperedge $e$ is considered covered at the first time when $k_e$ of its vertices appear in the ordering. We present a $4.509$-approximation algorithm for GMSSC, improving upon the previous best-known guarantee of $4.642$~\cite[SODA'21]{BansalBFT21}. Our approach retains the general LP-based framework of Bansal, Batra, Farhadi, and Tetali~\cite{BansalBFT21} but provides an improved analysis that narrows the gap toward the lower bound of $4$-approximation assuming P$\neq$NP. Our analysis takes advantage of the constraints of the linear program in a nontrivial way, along with new lower-tail bounds for the sums of independent Bernoulli random variables, which could be of independent interest.

0

cs.DS 2026-05-12 1 theorem

Dynamic rank updates now scale with rank r

Dynamic Rank, Basis, and Matching

Algorithms achieve Õ(r^1.405) time per entry change and extend to maintaining maximum matching size in graphs.

abstract click to expand

We study dynamic algorithms for maintaining fundamental algebraic properties of matrices, specifically, rank, basis, and full-rank submatrices, with applications to maximum matching on dynamic graphs. Prior dynamic algorithms for rank achieve subquadratic update times but scale with the matrix dimension $n$, and could not always maintain the corresponding objects such as a basis or maximum full-rank submatrix. We present the first dynamic rank algorithms whose update time scales with the matrix rank $r$, achieving $\tilde O(r^{1.405})$ time per entry-update and $\tilde O(r^{1.528}+ z)$ per column-update, where $z$ is the number of changed entries. This extends to $\tilde O(|M|^{1.405})$ edge-update time to maintain the size $|M|$ of a maximum matching. We also give dynamic algorithms for maintaining a column-basis subject to column-updates and a maximum full-rank submatrix subject to entry-updates.

0

cs.DS 2026-05-11 2 theorems

Online Steiner forest achieves constant ratio with O(log n) recourse

Online Steiner Forest with Recourse

An algorithm keeps connectivity costs low for arriving terminal pairs while changing only O(log n) edges per demand on average.

abstract click to expand

In the online Steiner forest problem we are given a graph $G$, and a sequence of terminal pairs $(u_i,v_i)$ which arrive in an online fashion. We are asked to maintain a low-cost subgraph in which each $u_i$ is connected to $v_i$ for all the pairs that have arrived so far. If we are not allowed to delete edges from our solution, then the best possible competitive ratio is $\Theta(\log n)$. In this work, we initiate the study of low-recourse algorithms for online Steiner forest. We give an algorithm that maintains a constant-competitive solution and has an amortized recourse of $O(\log n)$, i.e., inserts and deletes $O(\log n)$ edges per demand on average.

0

cs.DS 2026-05-11 Recognition

Streaming max-cut needs linear space in dense graphs

Streaming Complexity Separations for Dense and Sparse Graphs

Graphs with about n/ε² edges require an extra logarithmic factor to output the approximate cut

abstract click to expand

We identify a sharp separation in the streaming space complexity of Maximum Cut when the algorithm must output an approximate cut (rather than only the approximate value). For dense graphs, we show that $O(n/\varepsilon^2)$ space is sufficient and that $\Omega(n)$ space is necessary. In contrast, for graphs with $\Theta(n/\varepsilon^2)$ edges, the situation is markedly different: we show that the problem requires $\Omega(n \log(\varepsilon^2 n)/\varepsilon^2)$ space for any $\varepsilon=\omega(1/\sqrt{n})$, which is tight for the full range of $\varepsilon$. We also give an $\Omega(n \log n/\varepsilon^2)$-space lower bound against deterministic algorithms for outputting a $(1-\varepsilon)$ approximation to the value of the maximum cut. Using similar techniques we prove an analogous sharp separation in the streaming space complexity of Densest Subgraph and show that for every constant-arity CSP over a constant-size alphabet and the Similarity problem the space complexity in dense streams can be improved by shaving a logarithmic factor.

0

cs.DS 2026-05-11 Recognition

GenusSink makes Sinkhorn near-linear on planar graphs

Near-Linear Time Generalized Sinkhorn Algorithms for Bounded Genus Graphs

Separator decompositions and fast distance matrix multiplies let approximate geodesic optimal transport scale to large meshes.

abstract click to expand

We present GenusSink, a new class of approximate generalized Sinkhorn algorithms with shortest-path-distance costs for bounded genus (e.g. planar) graphs, providing near-linear time: (1) pre-processing, (2) iteration step, (3) final transport plan matrix querying and near-linear memory. Graphs handled by GenusSink include in particular planar graphs and bounded-genus meshes approximating 3D objects. GenusSink addresses total quadratic time complexity of its brute-force counterpart by leveraging separator-based decomposition of graphs, computational geometry techniques, and new results on fast matrix-vector multiplications with generalized distance matrices, using, in particular, Fourier analysis and low displacement rank theory. It is inspired by recent breakthroughs in graph theory on approximating bounded genus metrics with small treewidth metrics \citep{minor-free-paper}. The graph-centric approach enables us to target optimal transport problem with the corresponding distributions defined on the manifolds approximated by weighted graphs and with cost functions given by geodesic distances. We conduct rigorous theoretical analysis of GenusSink, provide practical implementations, leveraging newly introduced in this paper \textit{separation graph field integrators} (S-GFIs) data structures and present empirical verification. GenusSink provides orders of magnitude more accurate computations than other efficient Sinkhorn algorithms, while still guaranteeing significant computational improvements, as compared to the baseline. As a by-product of the developed methods, we show that GenusSink is \textbf{numerically equivalent} to the brute-force geodesic Sinkhorn algorithm on $n$-vertex graphs with treewidth $O(\log \log (n))$ (e.g. on trees).

0

cs.DS 2026-05-11 2 theorems

Engine combines DP routines to test Boolean graph properties on bounded treewidth

TreeWidzard: An Engine for Width-Based Dynamic Programming and Automated Theorem Proving

Given any Boolean formula of properties and an integer k, it decides whether every graph of treewidth at most k satisfies the formula.

abstract click to expand

In this work, we introduce TreeWidzard, an engine for developing dynamic programming algorithms that decide graph-theoretic properties parameterized by treewidth and pathwidth. Besides providing a unified framework for algorithms deciding atomic graph-theoretic properties, our engine allows one to combine such algorithms for two purposes: to obtain dynamic programming algorithms for more complex graph properties, and to support treewidth-based automated theorem proving. Within this context, given the specification of a Boolean combination $P$ of graph properties $P_1, P_2, \ldots, P_r$, and a positive integer $k$, our engine can be used to determine whether all graphs of treewidth at most $k$ satisfy $P$. The main goal of the present work is to provide a system description of TreeWidzard. In particular, we provide a step-by-step account of how to implement dynamic programming algorithms in our framework and how to combine these algorithms for model checking and automated theorem proving.

0

cs.DS 2026-05-11 2 theorems

Canonization and pruning verify Reed conjecture up to pathwidth 5

State Canonization and Early Pruning in Width-Based Automated Theorem Proving

The reductions let a dynamic-programming search prove the conjecture holds for all triangle-free graphs of pathwidth at most 5 and treewidth

abstract click to expand

Width-based automated theorem proving is a framework where counterexamples to graph-theoretic conjectures are searched width-wise relative to some graph width measure, such as treewidth or pathwidth. In a recent work it has been shown that dynamic programming algorithms operating on tree decompositions can be combined together with the purpose of width-based theorem proving. This approach can be used to show that several long-standing conjectures in graph theory can be tested in time $2^{2^{k^{O(1)}}}$ on the class of graphs of treewidth at most $k$. In this work, we give the first steps towards evaluating the viability of this framework from a practical standpoint. At the same time, we advance the framework in two directions. First, we introduce a state-canonization technique that significantly reduces the number of states evaluated during the search for a counterexample of the conjecture. Second, we introduce an early-pruning technique that can be applied in the study of conjectures of the form $\mathcal{P}_1 \rightarrow \mathcal{P}_2$, for graph properties $\mathcal{P}_1$ and $\mathcal{P}_2$, where $\mathcal{P}_1$ is a property closed under subgraphs. As a concrete application, we use our framework in the study of graph-theoretic conjectures related to coloring triangle-free graphs. In particular, our algorithm is able to show that Reed's conjecture for triangle-free graphs is valid on the class of graphs of pathwidth at most 5, and on graphs of treewidth at most 3. Perhaps more interestingly, our algorithm is able to construct in a completely automated way counterexamples to invalid strengthenings of Reed's conjecture. These are the first results showing that width-based automated theorem proving is a promising avenue in the study of graph-theoretic conjectures.

0

cs.DS 2026-05-11 Recognition

Greedy recolors O(1/sqrt(Delta)) edges per insertion on forests

Dynamic Edge Coloring of Forests

Incremental case stays efficient while fully dynamic forests need randomization or rooting to avoid logarithmic recoloring chains.

abstract click to expand

In the \emph{dynamic edge coloring} problem, one has to maintain a graph of maximum degree $\Delta$ with at most $\Delta+c$ colors, given updates to the edges of the graph. An important objective is to minimize the \emph{recourse}, which is the number of edges being recolored. We study this problem on forests, which is a natural yet nontrivial restriction of the problem. We consider the problem in both \emph{incremental} (edges are only inserted) and \emph{fully dynamic} (edges may be deleted) models. In the deterministic setting, we show that the natural greedy algorithm achieves $O(\frac{1}{c + \sqrt{\Delta}})$ amortized recourse in the incremental model, and this is tight up to tie-breaking. In contrast, in a fully dynamic forest, greedy can be forced to have $\Omega(\log_\Delta n)$ amortized recourse. To partially alleviate this limitation of greedy, we show an optimal non-greedy algorithm with $O(1)$ amortized recourse for \emph{rooted} fully dynamic forests and $c = \Delta - 2$. In the randomized setting, we give a natural distribution-maintaining algorithm that achieves $\Theta(\frac{1}{\Delta})$ expected amortized recourse in the incremental model and $\Theta(\min \{ \frac{\Delta}{c}, \log_{\Delta} n \})$ expected recourse in the dynamic model. These randomized results are optimal for $c=0$.

0

cs.DS 2026-05-11 Recognition

Small subsets approximate the global ranking median

A Scalable and Unified Framework to Weighted Rank Aggregation

Local one-medians on few inputs give (2-α) approximations in constant MPC rounds with sublinear local memory for Ulam and related distances.

abstract click to expand

The rank aggregation problem seeks to combine multiple rank orderings of the same set of candidates into a single consensus ordering. Such problems arise in diverse domains, including web search, employment, college admissions, and voting. In this work we focus on the 1-median objective: given a set of m rankings over [n], the goal is to compute a ranking that minimizes the sum of its distances to all input rankings. We study rank aggregation under several classical distance metrics: Ulam distance, Spearman's footrule, Hamming distance, and Kendall-tau, as well as their weighted variants. Our contributions begin with a novel unified framework that identifies a key structural property: it suffices to focus on a small subset of rankings, where the corresponding local one-median provides a good approximation to the global median. This principle extends across these distance measures, yielding a general algorithmic framework for weighted rank aggregation. Building on this, we present a new approximation algorithm for rank aggregation under the Ulam distance that scales in the Massively Parallel Computation (MPC) model. Our algorithm computes a $(2-\alpha)$-approximation, for a constant $\alpha>0$, to the 1-median in a constant number of rounds, using local memory sublinear in n and total memory near-linear in n. We further design new MPC approximation algorithms for Spearman's footrule and for the element-weighted variants of Hamming and Kendall-tau distances. For each metric, we obtain a $(2-\zeta)$-approximation, for a constant $\zeta>0$, to the 1-median in a constant number of rounds, using local memory sublinear in n and total memory linear or near-linear in n. Moreover, for the Ulam distance, we simplify and strengthen the analysis of Chakraborty et al., obtaining an improved 1.968-approximation that further extends to the weighted setting.

0

cs.DS 2026-05-11 Recognition

Deterministic algorithm finds high-order element or factors N

Deterministically finding an element of large order in mathbb{Z}_N^*

Runs in square-root-of-D time once D exceeds exp of sqrt(2 log N log log N), improving on prior N^{1/6} threshold.

abstract click to expand

In this paper, we present an improvement for the problem of deterministically finding an element of large multiplicative order modulo some integer $N$. This problem arises as a key subroutine in current deterministic factoring algorithms, such as those proposed by Harvey and Hittmeir [Mathematics of Computation, 2021]. Specifically, let $D<N$ be positive integers with \begin{equation}\label{eq:abs} D > \exp\left(\sqrt{2\log N \log \log N}\right). \end{equation} We give a deterministic algorithm that does one of the following: Returns an element $a \in \mathbb{Z}_N^*$ with $\operatorname{ord}_N(a) > D$; Returns a non-trivial factor of $N$; Or reports that $N$ is prime. The running time of our algorithm is $O(D^{1/2 + o(1)})$. Similar results were independently and concurrently obtained by Harvey and Hittmeir [arXiv:2601.11131, 2026] in work that appeared while this manuscript was in preparation. Prior to these works, the best known algorithm for finding an element with order larger than $D$ was given by Oznovich and Volk [SODA 2026], requiring $D > N^{\frac{1}{6}}$. We also present a simpler algorithm that applies for any $D < N$ and runs in $O(D^{2.5+o(1)}\operatorname{polylog}(N))$.

0

cs.DS 2026-05-11 2 theorems

Min-cost flows fit in subquadratic streaming space

Computing Flows in Subquadratic Space

Algorithm reports approximate flow on each edge as it is read in the last pass, using Õ(n^1.5) space and sidestepping quadratic lower bounds

abstract click to expand

Space complexity is a critical factor in various computational models, including streaming, parallel/distributed computing, and communication complexity. We study the space complexity of the minimum-cost flow problem, a generalization of the st-max flow problem, focusing on computing flows in subquadratic space. In the general case with arbitrary capacities, minimum cost and $st$-maximum flows can use up to $\Omega(n^2)$ edges, so computing the flow on each edge (rather than just the size/cost) seems impossible in subquadratic space. Indeed, there are lower bounds proving quadratic space is needed to store the flow on every edge, which has been used to prove lower bounds on streaming algorithms. However, we show that these lower bounds can be circumvented, opening up improvements for streaming and communication complexity. For a directed graph with integer capacities and costs bounded by $W$, we provide a $\tilde O(n^{1.5}\log (W/\epsilon))$-space $\tilde O(\sqrt{n} \log(W/\epsilon))$-pass streaming algorithm, which during the last pass returns the flow on each edge up to an additive error of $\epsilon$. Crucially, the algorithm does not return the flow at the end of the last pass but returns the flow on an edge, as the edge is read in the stream. This allows us to circumvent existing $\Omega(n^2)$ space lower bounds. In the 2-party communication model, our algorithm implies $\tilde O(n^{1.5}\log^2 W)$ bits of communication.

0

cs.DS 2026-05-11 Recognition

Deterministic algorithms cannot hit both time and I/O optima for convex hulls

The Impossibility of Simultaneous Time and I/O Optimality for The Planar Maxima and Convex Hull Problems

Planar maxima and hull problems force deterministic output-sensitive methods to trade off speed against memory accesses.

abstract click to expand

We prove that no deterministic output-sensitive algorithm for the planar convex hull and maxima problems can obtain both optimal time and I/O complexity, where the optimality is defined with respect to both the input and output sizes. This explains why the best previous algorithms achieved an optimal I/O bound at the cost of sub-optimal running time (Goodrich et al. [FOCS, 1993]). To the best of our knowledge, the impossibility of simultaneous optimality was only shown previously for the permutation problem by Brodal and Fagerberg [STOC, 2003]. Our results imply that no optimal deterministic output-sensitive cache-oblivious algorithm exists for either problem. In addition, we present simple deterministic algorithms that match our lower bounds and that provide a trade-off between time and I/Os. On the other hand, a simple modification of our deterministic algorithm results in a randomized algorithm that simultaneously achieves optimal (worst-case) time and optimal expected I/O bounds.

0

cs.DS 2026-05-11 2 theorems

Weighted graphs get nearly equitable colorings with O(Δ) colors

Equitable Colorings of Vertex-Weighted Graphs

A (1+ε) guarantee needs only (c/ε² log(1/ε))Δ colors; a factor-2 guarantee works at Δ+1 colors and both are polynomial-time computable.

abstract click to expand

We study a generalization of the classical Hajnal-Szemer\'edi theorem to vertex-weighted graphs. Given a graph with nonnegative vertex weights, a coloring is called $\alpha$-approximately equitable up to one vertex ($\alpha$-EQ1) if, for each color class, the total weight remaining after removing its maximum-weight vertex is at most $\alpha \geq 1$ times the weight of any other color class. For vertex-weighted graphs with maximum degree $\Delta$, we show that there exist instances for which no $k$-coloring is $\alpha$-EQ1 for any $k < \frac{3\Delta}{2}$ and $\alpha < \sqrt{2}$. In light of this impossibility, we relax these parameters and establish the following results for any vertex-weighted graph $G$ with maximum degree $\Delta$: (1) for any $\varepsilon \in (0,1)$ and all $k \geq (\frac{c}{\varepsilon^2}\ln{\frac{1}{\varepsilon}}) \Delta$, there exists a $(1 + \varepsilon)$-EQ1 $k$-coloring of $G$, where $c$ is a fixed constant; and (2) for all $k \ge \Delta + 1$, there exists a $2$-EQ1 $k$-coloring of $G$. Furthermore, such equitable colorings can be computed in polynomial time. En route to our results on equitability under vertex weights, we establish sufficient conditions for the existence of $k$-colorings that are equitable with respect to any given partition of the vertex set. Our coloring results correspond to fairness guarantees in a constrained fair division setting and lead to concentration inequalities for partly dependent random variables.

0

cs.DS 2026-05-11 Recognition

Algorithm finds induced diamonds in Õ(n^{2.425}/t^{0.25}) time

Witness-Sensitive Detection of Induced Diamonds

The witness-sensitive method improves on matrix-multiplication time once the graph contains enough such subgraphs.

abstract click to expand

We provide a fast \emph{witness-sensitive} algorithm for detecting an induced diamond (a $K_4$ minus an edge) in an $n$-vertex graph containing $t$ induced diamonds. Our algorithm runs in time $\tilde{O}(\min(n^{2.425}/t^{0.25}+n^2, n^\omega))$ with high probability, improving upon the prior state of the art (witness-oblivious) algorithm that runs in time $O(n^\omega\log{n})$ [Vassilevska Williams, Wang, Williams, Yu, SODA 2014] whenever $t \geq n^{(3-\omega)/3}$, where $\omega < 2.372$ is the matrix multiplication exponent. Our key insight is that the size of a clique containing one of the triangles of an induced diamond plays a crucial role in detecting such a diamond. We say that a diamond is $r$-heavy if this size is at least $r$, and we provide a fast detection algorithm for $r$-heavy diamonds in $\tilde{O}(r \cdot (n/r)^\omega + (n/r)^3+ nr)$ time. When there are no $r$-heavy diamonds, we provide a different fast detection algorithm in $\tilde{O}(\mathsf{MM}(n,n,n\sqrt{r/t}))$ time, where $\mathsf{MM}(a,b,c)$ denotes the time to multiply an $a \times b$ matrix by a $b \times c$ matrix, which is conditionally optimal for $r=\tilde{O}(1)$. Our main technical contribution is in designing a refinement framework for sampling vectors, which allows sampling vertices for detecting diamonds in a manner that is adaptive to the structure of graphs with no $r$-heavy diamonds. We establish that our technique is of a wide applicability, by showing how it also allows for faster witness-sensitive algorithms for $4$-SUM and for a special case of $4$-cycles.

0

cs.DS 2026-05-11 1 theorem

Simpler algorithm solves node-weighted triangles in MM(n) time

Node-Weighted Triangles: Faster and Simpler

The method removes the last superpolylogarithmic overhead that separated weighted from unweighted triangle detection.

abstract click to expand

Weighted variants of triangle detection are an important object of study because of their prominence in fine-grained complexity. We revisit the Node-Weighted Triangle problem, where the goal is to decide if a vertex-weighted graph contains a triangle whose node weights sum to zero. This problem has been the focus of a celebrated line of work, beginning with a subcubic-time algorithm [Vassilevska, Williams; STOC '06], and culminating in algorithms running almost in matrix multiplication time, $O(\textsf{MM}(n) + n^2\cdot 2^{O(\sqrt{\log n})})$ [Czumaj, Lingas; SODA '07], [Vassilevska W., Williams; STOC '09]. This runtime is almost-optimal, since even detecting an unweighted triangle is conjectured to require matrix multiplication time $\textsf{MM}(n)$. However, the superpolylogarithmic $2^{\Omega(\sqrt{\log n})}$ overhead persists in a world where near-optimal matrix multiplication is possible (i.e., $\textsf{MM}(n) \leq n^2\text{poly}(\log n)$). In this paper, we present a new algorithm solving Node-Weighted Triangle in $O(\textsf{MM}(n))$ time, closing the gap to unweighted triangle detection completely. Remarkably, our algorithm is much simpler than previous approaches, which use involved recursion schemes and communication protocols.

0

cs.DS 2026-05-11 Recognition

Online factorization matches offline error up to logs

Online Matrix Factorization, Online Private Query Release, and Online Discrepancy Minimization

New algorithm handles arriving query rows one by one while staying competitive with best offline matrix factorizations for private release.

abstract click to expand

In this paper we consider several related online computation problems. First, we study answering sequences of statistical queries arriving online, and being answered immediately when they arrive with differential privacy. Known matrix factorization mechanisms can answer a set of statistical queries with error bounded by the $\gamma_2$ norm of their query matrix, but require that all queries are known in advance. We show that nearly the same error bounds can be achieved in the online setting for non-adaptively chosen queries. To do so, we give an online factorization algorithm that competitively matches the best offline factorization up to logarithmic factors. In the online matrix factorization problem, a new row $q_t$ of a matrix arrives at each time step $t$, and the algorithm needs to maintain a factorization $L_tR_t=Q_t$ such that at each time it appends some rows to $R_t$, and outputs a new row $\ell_t$ s.t. $\ell_tR_t=q_t$. Our algorithm maintains the competitiveness over this online process, even if the number of rows to arrive is unknown. As another application, we give an online discrepancy minimization algorithm that achieves discrepancy competitive against the $\gamma_2$ norm (and also against hereditary discrepancy) up to logarithmic factors.

0

cs.DS 2026-05-11 Recognition

Evacuation ratio bounded by 4+2√2 with majority reliable agents

Search and evacuation with a near majority of faulty agents

When n equals 2f plus 1, new coordination limits worst-case time to at most 7.437 times the distance for three agents and 4 plus 2 times the

abstract click to expand

There are $n\geq 3$ unit speed mobile agents placed at the origin of the infinite line. In as little time as possible, the agents must find and evacuate from an exit placed at an initially unknown location on the line. The agents can communicate in the wireless mode in order to facilitate the evacuation (i.e. by announcing the target's location when it is found). However, among the agents are a subset of at most $f$ crash faulty agents who may fail to announce the target when they visit its location. In this paper we study this aforementioned problem for the specific case that $n=2f+1$. We introduce a novel type of search algorithm and analyze its competitive ratio -- the supremum, over all possible target locations, of the ratio of the time the agents take to evacuate divided by the initial distance between the agents and the target. In particular, we demonstrate that the competitive ratio of evacuation is at most $7.437011$ for $(n,f)=(3,1)$; at most $7.253767$ for $(n,f)=(5,2)$ and $(7,3)$; and at most $7.147026$ for $(n,f)=(9,4)$. For larger values of $n=2f+1$ we prove an asymptotic upper bound of $4+2\sqrt{2}$. We also adapt our evacuation algorithm for $(n,f)=(3,1)$ to the problem of search by three agents with one byzantine fault, i.e. the faulty agent may also lie about finding the target. In doing so we improve the best known upper bound on this search problem from 8.653055 to 7.437011.

0

cs.DS 2026-05-11 Recognition

Planarizing gadgets do not exist for (k,l)-tight graphs

Planarizing Gadgets for (k, l)-tight Graphs Do Not Exist

The usual reduction from general instances to planar ones is impossible.

abstract click to expand

The problem of recognizing (k, l)-tight graphs is a fundamental problem that has close connections to well studied problems like graph rigidity. The problem is better understood for planar graphs as compared to general graphs. For example, deterministic NC-algorithms for the problem are known for planar graphs, but no such algorithm is known for general graphs. A common approach to reduce a graph problem to the planar case is to use planarizing gadgets. Our main contribution is to show that, unconditionally, planarizing gadgets for the problem of recognizing (k, l)-tight graphs do not exist.

0

cs.DS 2026-05-11 Recognition

Vertex cover local search runs in ℓ^{f(k)} n time

Parameterized Local Search for Vertex Cover: When only the Search Radius is Crucial

With k fixed as a user constant, structural parameters like treewidth or h-index control the cost of finding improving swaps.

abstract click to expand

A vertex set $W$ in a graph $G$ is a valid $k$-swap for a vertex cover $S$ of $G$ if $W$ has size at most $k$ and $S'=(S \setminus W) \cup (W \setminus S)$, the symmetric difference of $S$ and $W$, is a vertex cover of $G$. If $|S'| < |S|$, then $W$ is improving. In LS Vertex Cover, one is given a vertex cover $S$ of a graph $G$ and wants to know if there is a valid improving $k$-swap for $S$ in $G$. In applications of LS Vertex Cover, $k$ is a very small parameter that can be set by a user to determine the trade-off between running time and solution quality. Consequently, $k$ can be considered to be a constant. Motivated by this and the fact that LS Vertex Cover is W[1]-hard with respect to $k$, we aim for algorithms with running time $\ell^{f(k)}\cdot n^{\mathcal{O}(1)}$ where $\ell$ is a structural graph parameter upper-bounded by $n$. We say that such a running time grows mildly with respect to $\ell$ and strongly with respect to $k$. We obtain algorithms with such a running time for $\ell$ being the $h$-index of $G$, the treewidth of $G$, or the modular-width of $G$. In addition, we consider a novel parameter, the maximum degree over all quotient graphs in a modular decomposition of $G$. Moreover, we adapt these algorithms to the more general problem where each vertex is assigned a weight and where we want to find a valid $d$-improving $k$-swap, that is, a valid $k$-swap which decreases the weight of the vertex cover by at least $d$.

0

cs.DS 2026-05-11 Recognition

Lettericity word and decoder retrieval solved in polynomial time

Towards Settling the Complexity of the Lettericity Problem

Coloring retrieval matches graph isomorphism complexity; symmetric lettericity equals neighborhood diversity and runs in linear time.

abstract click to expand

The lettericity of a graph $G=(V,E)$ is defined as the smallest size of an alphabet $\Sigma$ such that there is a word $w_1 \dots w_{|V|} \in \Sigma^*$ and a decoder $\mathcal{D} \subseteq \Sigma^2$ with the property that $G$ is isomorphic to the letter graph $G(\mathcal{D}, w)$, that is, the graph with vertex set $\{1, \dots, n\}$ and edge set $\{ij \mid 1\leq i < j \leq n, w_iw_j \in \mathcal{D}\}$. Note that $G(\mathcal{D}, w)$ can be seen as a graph with inherent coloring $\chi \colon V(G) \rightarrow \Sigma$. It is unknown whether the lettericity of a given graph can be computed in polynomial time. The problem to determine the lettericity of a given graph is called the lettericity problem. As a step towards answering the complexity of this problem, we investigate the following retrieval problems: given a graph $G$ together with two of the three solution-objects (word $w$, decoder $\mathcal{D}$, and coloring $\chi$), the goal is to compute the third solution-object. We show that word retrieval and decoder retrieval are solvable in polynomial time, while coloring retrieval is equivalent to the graph isomorphism problem. Beyond this, we introduce symmetric lettericity which is a restricted version of lettericity where each decoder needs to be symmetrical ($ab\in \mathcal{D}$ if and only if $ba\in \mathcal{D}$). As we show, the symmetric lettericity of a graph always equals the neighborhood diversity of the graph, which in fact can be computed in linear time.

0

cs.DS 2026-05-11 Recognition

Algorithm computes Hermite form of relation lattices at matrix mult cost

Computing bases in Hermite normal form of lattices of integer relations

When the input matrix is square the procedure returns the standard Hermite normal form using time comparable to a constant number of matrix

abstract click to expand

Given a full column rank $M \in \Z^{\ell \times m}$ and an $F \in \Z^{n \times m}$ we present an algorithm to compute the $n \times n$ basis in Hermite form of the integer lattice comprised of all rows $p \in \Z^{1 \times n}$ such that $pF \in \Z^{1 \times m}$ is in the integer lattice generated by the rows of $M$. The algorithm is randomized of the Las Vegas type, that is, it can fail with probability at most $1/2$, but if fail is not returned it guarantees to produce the correct result. When $M$ is square and $F=I_m$, then the computed basis is the Hermite normal form of $M$, and the algorithm uses about the same number of bit operations as required to multiply together two matrices of the same dimension and size of entries as $M$.

0

cs.DS 2026-05-11 Recognition

One pass computes (Δ-1)-coloring for large-degree graphs

Beyond Brooks: (Delta-1)-Coloring in Semi-Streaming

Graphs with maximum degree ≥10^14 and no Δ-clique receive a proper (Δ-1)-coloring after a single pass over their edges in semi-streaming.

abstract click to expand

Reed [J.~Comb.~Theory B, 1999] showed that graphs of maximum degree $\Delta \geq 10^{14}$ without $\Delta$-cliques are $(\Delta-1)$-colorable. We design a one-pass semi-streaming algorithm for computing such a coloring. Additionally, we prove that any one-pass $(\Delta-k)$-coloring algorithm for $0\leq k < (\Delta+1)/2$ requires $\Omega(n(k+1))$ space.

0

cs.DS 2026-05-11 Recognition

Deterministic streaming colors with O(Δ) colors in O(sqrt(log Δ)) passes

Faster Deterministic Streaming Vertex Coloring

New algorithm cuts passes from O(log Δ) to sublogarithmic while using linear memory and a linear-in-Δ palette.

abstract click to expand

Graph coloring is a fundamental problem in computer science. In the semi-streaming model, an input graph $G$ on $n$ vertices and maximum degree $\Delta$ is presented as a stream of edges, and the goal is to compute a vertex coloring using a small number of colors while storing only $\tilde{O}(n)$ bits of memory. Recent work has revealed an exponential separation between randomized and deterministic approaches in this setting: while randomized algorithms can achieve a $(\Delta+1)$-coloring in a single pass [Assadi, Chen, and Khanna, 2019], any single-pass deterministic algorithm requires $\exp(\Delta^{\Omega(1)})$ colors [Assadi, Chen, and Sun, 2022]. Consequently, deterministic algorithms that use few colors must necessarily make multiple passes over the stream. Prior to this work, the best known deterministic trade-offs were: an $O(\Delta^2)$-coloring in 2 passes, an $O(\Delta)$-coloring in $O(\log \Delta)$ passes [Assadi, Chen, and Sun, 2022], and a $(\Delta+1)$-coloring in $O(\log \Delta \cdot \log\log \Delta)$ passes [Assadi, Chakrabarti, Ghosh, and Stoeckl, 2023]. It remained open whether better trade-offs -- particularly with sub-logarithmic pass complexity and linear-in-$\Delta$ palette size -- were achievable. In this paper, we present a new deterministic semi-streaming algorithm that computes an $O(\Delta)$-coloring in $O(\sqrt{\log \Delta})$ passes. This is the first deterministic streaming algorithm to achieve a coloring with palette size linear-in-$\Delta$ using sublogarithmic-in-$\Delta$ passes.

0

cs.DS 2026-05-11 Recognition

Coordinated robot motion is FPT on polygon discretizations

Coordinated Motion Planning is FPT on Discretized Simple Polygons

Algorithm parameterized by robot count solves the problem on graphs from simple polygons, generalizing rectangular cases and advancing to pl

abstract click to expand

In the coordinated motion planning problem, we are given a graph together with the starting and destination vertices of $k$ robots. At each time step, any subset of robots may move, each traversing an edge of the graph, provided that no two robots collide. The goal is to compute a schedule that routes all robots to their destinations while minimizing some objective function. In this paper, we focus on the well-studied objective of minimizing the total travel length of all robots. This problem is known to be NP-hard, and it has been shown to be fixed-parameter tractable (FPT), when parameterized by the number $k$ of robots, on full grids (SoCG 2023) and on bounded-treewidth graphs (ICALP 2024). We present a fixed-parameter algorithm for coordinated motion planning, parameterized by the number $k$ of robots, on graphs arising from discretizations of simple polygons. Such graphs are of particular interest in real-world applications, where planar motion is often constrained to discretized representations of polygonal environments. Moreover, these graphs generalize rectangular grids; consequently, our result constitutes a significant step toward resolving the parameterized complexity of coordinated motion planning on subgrids and, ultimately, planar graphs -- two prominent open problems in the field.

0

cs.DS 2026-05-11 Recognition

Bidding profiles close gap for randomized online bidding

Optimal Learning-Augmented Algorithm for Online Bidding

Any algorithm reduces to a distribution over bids whose optimum satisfies delayed differential equations, achieving Pareto-optimal trade-off

abstract click to expand

Recent advances in machine learning have spurred significant interest in learning-augmented algorithms, particularly for online optimization. A growing body of work has studied online bidding in this framework, aiming to characterize the trade-off between robustness and consistency. While this trade-off is fully understood for deterministic algorithms, a gap between upper and lower bounds remains in the randomized setting. In this paper, we close this gap by presenting a Pareto-optimal randomized learning-augmented algorithm for this problem. Our approach introduces the notion of a bidding profile, a novel framework for representing the distribution over bids generated by an algorithm. We show that any bidding algorithm can be reduced, without loss of generality, to one driven by a bidding profile, and we characterize the optimal profile via a system of delayed differential equations. Finally, we demonstrate the broader applicability of our approach by extending it to the linear search problem, yielding a significant improvement over prior learning-augmented algorithms for linear search.

0

cs.DS 2026-05-11 Recognition

Backreference regex matching needs n to the 2k power

On the Complexity of the Matching Problem of Regular Expressions with Backreferences

Hardness results rule out faster algorithms for k references while single-use cases finish in near-linear time with log factors.

abstract click to expand

ReDoS is a well-known type of algorithmic complexity attack, where an adversary supplies maliciously crafted strings to a regular expression matching engine, aiming to exhaust computational resources of systems. Even quadratic-time behavior in matching engines has been exploited in successful attacks, as exemplified by major outages at Stack Overflow (2016) and Cloudflare (2019). These incidents motivate a fundamental question: Is it possible to construct matching engines that are provably efficient, running in (near-)linear time in the length of the input string? For classical regular expressions (REGEX), Thompson's construction yields a linear-time algorithm. However, practical engines support powerful features such as backreferences, which strictly extend the expressive power of REGEX but unfortunately increase the risk of ReDoS attacks. This paper investigates the fine-grained complexity of the string matching problem for regular expressions with backreferences (REWBs). Specifically, we consider $r$-use $k$-REWBs. On the hardness side, we show that the string matching problem for $k$-REWBs cannot be solved in $O(n^{2k-\epsilon})$ time for any $\epsilon > 0$ under SETH. We also prove that this problem is \textbf{W[2]}-hard when parameterized by the length of the REWB expression, strengthening the previous \textbf{W[1]}-hardness. Moreover, we prove that this problem for $2$-use $2$-REWBs cannot be solved in $n^{1+o(1)}$ time unless the triangle detection problem can be solved in that time. On the algorithmic side, we present an $O(n \log^2 n)$-time algorithm for $1$-use REWBs, which significantly improves upon the recent $O(n^2)$-time algorithm by Nogami and Terauchi (MFCS, 2025). Our algorithm employs several techniques including suffix trees, transition monoids of REGEXes, factorization forest data structures, and periodicity of strings.

0

cs.DS 2026-05-11 1 theorem

EPTAS for ConstrainedMinCut on everywhere-dense graphs

EPTAS for Hard Graph Cut Problems for Dense Graphs

Weak regularity lemma plus sampling gives f(1/ε) n^O(1) time for ConstrainedMinCut, MinQuotientCut, and ProductSparsestCut.

abstract click to expand

Everywhere-$\delta$-dense graphs are defined as graphs on $n$ vertices in which every vertex has degree at least $\delta n$ for some constant $\delta > 0$. Approximation schemes are vital for handling NP-hard optimization problems, but for many graph cut problems, existing PTAS algorithms often suffer from running times of $n^{f(1/\varepsilon)}$. In this paper, we bring PTASs down to EPTASs for several fundamental minimization problems on everywhere-$\Omega(1)$-dense graphs. Specifically, we present the first Efficient Polynomial-Time Approximation Scheme (EPTAS), running in time $f(1/\varepsilon)n^{O(1)}$, for the ConstrainedMinCut problem under a global constraint on vertex weights, a problem that captures BalancedSeparator and SmallSetExpansion. Moreover, we give the first EPTASs for MinQuotientCut and ProductSparsestCut on everywhere-$\delta$-dense graphs with integer-valued dense vertex weights; these problems generalize the four well-known problems UniformSparsestCut, EdgeExpansion, Conductance, and NormalizedCut. Our main technical contribution is an EPTAS for ConstrainedMinCut, based on the weak regularity lemma and sampling and estimation techniques. We then obtain EPTASs for MinQuotientCut and ProductSparsestCut via a unified reduction that invokes this algorithm as a subroutine. In contrast, previous works giving PTASs for these problems on everywhere-$\delta$-dense graphs typically rely on powerful tools such as the Lasserre hierarchy or specific integer programming technique, which we avoid.

0

cs.DS 2026-05-11 2 theorems

Oracle answers connectivity after k failures in O(k) time

Connectivity Oracle Under Vertex Failures by Shortcutting Unbreakable Decomposition

O(k^6) update independent of n, near-linear space and preprocessing when k is constant.

abstract click to expand

We give an improved connectivity oracle under vertex failures. After a set of $k$ vertices fails, our oracle performs an $O(k^{6})$-time update independent of the graph size $n$, and then answers pairwise connectivity queries in optimal $O(k)$ time. For constant $k$, it uses near-linear space and can be built in near-linear preprocessing time. In contrast, all prior oracles with $n$-independent update time[PSS+22, vdBS19] either require $\Omega(n^{2})$ space or incur $2^{2^{O(k)}}$ update and query time. Moreover, their preprocessing time is polynomially large in $n$, far from near-linear. Our oracle builds on the unbreakable decomposition framework of[PSS+22], but introduces three new ingredients: (i) shortcutting over the tree decomposition to reduce space from quadratic to near-linear, (ii) bootstrapping that leverages $n$-dependent oracles internally to obtain near-linear preprocessing, and (iii) a new patch set mechanism that yields conditionally optimal $O(k)$ query time.

0

cs.DS 2026-05-11 2 theorems

Deterministic Monotone Min-Plus Product hits O(n^{2.686}) time

Deterministic Monotone Min-Plus Product and Convolution

It removes randomization from the fastest algorithms for edit distance, RNA folding, and tree edit distance without any loss in speed.

abstract click to expand

The Monotone Min-Plus Product problem is a useful primitive that has seen many algorithmic applications over the past decade. In this problem, we are given two $n\times n$ integer matrices $A$ and $B$, where each row of $B$ is a monotone non-decreasing sequence of integers from $\{1,\dots,n\}$, and the goal is to compute their Min-Plus product, defined as the $n\times n$ matrix $C$ with $C_{i,j} = \min_{k}\{A_{i,k} + B_{k,j}\}$. The fastest known algorithm for this task [Chi, Duan, Xie, and Zhang, STOC'22] runs in $n^{(\omega+3)/2+o(1)} = O(n^{2.686})$ time, significantly improving over the brute-force cubic algorithm. However, its main disadvantage is that it requires randomization, which is then inherited by all downstream applications. Our main result is a deterministic algorithm for Monotone Min-Plus product with the same time complexity $n^{(\omega+3)/2+o(1)} = O(n^{2.686})$ as its randomized counterpart, improving upon the previous deterministic bound $O(n^{2.875})$ [Gu, Polak, Vassilevska Williams, and Xu, ICALP'21]. Our derandomization also applies to previously studied extensions and variants (e.g., [D\"urr, IPL'23]), including rectangular matrices, bounded range $[n^\mu]$, and column-monotone matrices. As an immediate consequence, we derandomize state-of-the-art algorithms for multiple problems, including Language Edit Distance, RNA Folding, Optimum Stack Generation, unweighted Tree Edit Distance, Batched Range Mode, and Approximate All-Pairs Shortest Paths. Our techniques also yield a deterministic algorithm for the Monotone Min-Plus Convolution problem that runs in $n^{1.5+o(1)}$ time, nearly matching the best known randomized time complexity $\widetilde{O}(n^{1.5})$ [Chi, Duan, Xie, and Zhang, STOC'22]. This algorithm can be used to derandomize state-of-the-art algorithms for Jumbled Indexing for binary strings and several variants of Knapsack.

0

cs.DS 2026-05-11 2 theorems

Node-arrival stream yields sublinear-space estimate of clustering cost

Estimating Correlation Clustering Cost in Node-Arrival Stream

C^4Approx stores only a small fraction of nodes yet matches offline pivot methods on real data sets with constant passes.

abstract click to expand

We study the correlation clustering problem in the node-arrival data stream model. Unlike previous work, where the stream consists of the graph's edges, we focus on the setting in which the stream contains only the nodes. This model better reflects many real-world scenarios in which the data stream naturally consists of raw objects (e.g., images, tweets), and the similar/dissimilar edges are derived through a similarity function. We present C$^4$Approx, a streaming algorithm that approximates the cost of correlation clustering using sublinear space in the number of nodes and a constant number of passes. We further complement this result with lower bounds. Experiments on real-world datasets show that by storing only 2% of the nodes, our algorithm achieves performance comparable to the classic Pivot algorithm and the more recent PrunedPivot algorithm, even on sparse graphs.

0

cs.DS 2026-05-08 Recognition

PQ and TDS learning models are equivalent for distribution-free Boolean classes

Equivalence of Coarse and Fine-Grained Models for Learning with Distribution Shift

A black-box reduction equates the two, yielding hardness for halfspaces but efficient algorithms with membership queries.

abstract click to expand

Recent work on provably efficient algorithms for learning with distribution shift has focused on two models: PQ learning (Goldwasser et al. (2020)) and TDS learning (Klivans et al. (2024)). Algorithms for TDS learning are allowed to reject a test set entirely if distribution shift is detected. In contrast, PQ learners may only reject points that are deemed out-of-distribution on an individual basis. Our main result is a surprising equivalence between these two models in the distribution-free setting. In particular, we give an efficient black-box reduction from PQ learning to TDS learning for any Boolean concept class. This equivalence implies the first hardness results for distribution-free TDS learning of basic classes such as halfspaces. The main technical contribution underlying our equivalence is a method for boosting, via branching programs, the weak distinguishing power of TDS learners that have rejected the target domain. We also show that giving a learner access to membership queries sidesteps these hardness results and allows for efficient, distribution-free PQ learnability of halfspaces. Our algorithm iteratively recovers large-margin separators obtained by applying successive Forster transforms on the training data.

0

cs.DS 2026-05-08 Recognition

Dynamic programming speeds ranked choice model estimation

Modern column generation for estimating single- and multi-purchase ranked list choice models

A new solver for the subproblem handles the explosion of consumer types and delivers faster fits for both single- and multi-purchase cases.

abstract click to expand

This paper studies the estimation of ranked-list discrete choice models with single and multiple purchases. In this setting, each consumer type is characterized by a ranking over a subset of products and a desired number of purchases, and the estimation task is to identify the set of consumer types and their probabilities that best explain the observed transactional data. This problem is computationally challenging due to the exponential number of possible consumer types and becomes more difficult when multiple purchases are allowed. We propose a column generation framework for this problem. Our main contribution is a dynamic programming algorithm for the column generation subproblem. This subproblem generalizes the linear ordering problem and incorporates acceleration techniques to improve computational efficiency. To the best of our knowledge, this is the first dynamic programming-based approach for generating consumer types in non-parametric models. The proposed framework supports multiple model variants with minor modifications. Computational experiments on synthetic and real data show substantial speedups over existing methods while maintaining high solution quality, and demonstrate effectiveness in both estimation and assortment optimization.

0

cs.DS 2026-05-08 3 theorems

Accelerated method reaches 0.827-approx for log coverage rewards

Accelerated Relax-and-Round for Concave Coverage Problems

Replaces LP solving with gradient descent on a surrogate and uses hypersimplex rounding to obtain tight guarantees in near-linear time.

abstract click to expand

We present an accelerated relax-and-round algorithm for concave coverage problems, which generalize the classic maximum coverage problem. Building on the relax-and-round framework of Barman et al. [STACS 2021], we propose two significant improvements. First, we replace the linear programming (LP) relaxation step with a projected accelerated gradient method applied to a smooth surrogate objective to achieve a $\widetilde{O}(mn \varepsilon^{-1})$ running time. Second, we use a specialized rounding scheme for the hypersimplex that combines the Carath\'eodory decomposition algorithm in Karalias et al. [NeurIPS 2025] with randomized swap rounding of Chekuri et al. [FOCS 2010]. We prove tight approximation ratios for new reward functions, including a $0.827$-approximation for the logarithmic reward $\varphi(x) = \log(1 + x)$. Finally, we conduct maximum multi-coverage experiments on synthetic and real-world graphs, demonstrating that our algorithm outperforms approaches that use state-of-the-art LP solvers.

0

cs.DS 2026-05-08 2 theorems

O(log m) approximation for multi-interface coverage

Polylogarithmic Approximation for Covering and Connecting Multi-Interface Networks

Randomized rounding of the LP relaxation also yields the first non-trivial O(log² m) guarantee for connectivity

abstract click to expand

We study problems related to connecting multi-interface networks of wireless devices. These problems are modeled using graphs, where vertices represent the devices and edges represent potential communication links. Each vertex can activate multiple interfaces, and a connection between two vertices is established if they share at least one common active interface. We consider two problems arising in multi-interface networks: Coverage and Connectivity. In the Coverage problem, every connection defined in the network must be established, while in the Connectivity problem, groups of terminals specified in the input should be connected. The solution should minimize the maximum cost incurred by a vertex or the total cost incurred by all vertices. In this work we are interested in approximating the former of the two cost criterions. We model both problems using ILPs and we design approximation algorithms based on a randomized rounding of the solution of the linear programming relaxation. For the Coverage problem, this yields an $O(\log m)$-approximation algorithm, which is tight, since the problem generalizes Set-Cover. This improves upon the $O(b\cdot\log n)$-approximation algorithm, where $b$ is a certain graph parameter which can be as large as $\Omega(n)$ [Algorithmica '12]. The same relaxation can also be used to get an $k$-approximation algorithm, where $k$ is the number of different interfaces. This generalizes a similar result for the uniform cost case. For the Connectivity problem, we obtain an $O(\log^2 m)$-approximation algorithm, which is the first non-trivial approximation algorithm for this problem. The algorithm is based on a similar LP relaxation with additional cut constraints to ensure connectivity. The rounding procedure is similar to the one for the Coverage problem but requires a more careful analysis to ensure that the connectivity constraints are satisfied.

0

cs.DS 2026-05-08

Deletion-only forest sums maintained in O(log* n) time

Fast decremental tree sums in forests

Micro-macro decomposition and precomputation beat standard log n bounds when no edge insertions occur after start.

abstract click to expand

We study two fundamental decremental dynamic graph problems. In both problems, we need to maintain a vertex-weighted forest of size $n$ under edge deletions, weight updates, and a certain information-retrieval query. Both problems can be solved in $O(\log n)$ time per update/query using standard dynamic forest data structures like top trees, even if additionally edge insertions are allowed. We investigate whether the deletion-only problem can be solved faster. First, we consider $\texttt{tree-sum}$ queries, where we ask for the sum of vertex weights in one of the connected components (i.e., trees) in the forest. We give a data structure with $O(n)$ preprocessing time and $O(\log^* n)$ time per operation, based on a micro-macro tree decomposition (Alstrup et al., 1997). If the forest is unweighted (i.e., all weights are 1 and cannot be changed), then the operation time can be improved to $O(1)$. Additionally, we give an asymptotically universally optimal algorithm. More specifically, our algorithm works in the group model, and processes $m$ operations on an initial forest $F$ in running time $O( \mathrm{OPT}(F, m) )$. Here $\mathrm{OPT}(F, m)$ is the number of weight additions and subtractions that a best possible algorithm performs to handle a worst-case instance for a fixed initial forest $F$ and a fixed number $m$ of operations. We achieve this with a combination of the aforementioned decomposition technique, precomputation of optimal data structures for very small instances, and some insights into the behavior of $\mathrm{OPT}$. Note that even the worst-case complexity of this algorithm remains unknown to us. Second, we consider $\texttt{subtree-sum}$ queries. Here, the forest is rooted, and a query $\texttt{subtree-sum}(v)$ returns the sum of weights in the subtree rooted at $v$. We show tight bounds for several variants of this problem. [...]

0

cs.DS 2026-05-08

Sum-of-radii clustering with k centers is W[2]-hard

On the Parameterized Approximability of (Mergeable) Sum of Radii Clustering

Hardness rules out (1+ε) FPT approximations unless W[2]=FPT, but mergeable constraints allow an (8/3+ε) FPT approximation and extend to fair

abstract click to expand

The sum of radii problem ($k$-MSR) asks, given a metric space on $n$ points, to place $k$ balls covering all points so as to minimize the sum of their radii. Despite extensive study from the perspectives of approximation and parameterized algorithms, the exact parameterized complexity of the problem and the existence of efficient parameterized approximation schemes remained open. We advance this understanding on both the hardness and algorithmic fronts. We begin by showing that $k$-MSR is $W[2]$-hard parameterized by $k$, thereby pinpointing its location in the $W$-hierarchy. Moreover, via our reduction, we rule out efficient parameterized approximation schemes (EPAS)--that is, $(1+\epsilon)$-approximations running in time $f(k,\epsilon)\cdot \mathrm{poly}(n)$--unless $W[2] = FPT$. Assuming the Exponential Time Hypothesis, we further rule out such algorithms running in time $f(k,\epsilon)\cdot n^{o(k)}$, strengthening recent lower bounds for the problem. On the algorithmic side, we study $k$-MSR under the framework of mergeable constraints, which captures a broad class of clustering constraints, including fairness, diversity, and lower bounds. We obtain an FPT $(\frac{8}{3}+\epsilon)$-approximation, improving upon the previous best guarantee of $(4+\epsilon)$. Moreover, given access to a suitable assignment subroutine, we achieve a $(2+\epsilon)$-approximation, matching the best known bound for the unconstrained problem. This, in turn, yields $(2+\epsilon)$ FPT-approximations for several important settings, including $(t,k)$-fair, $(\alpha,\beta)$-fair, $\ell$-diversity, and private clustering.

0

cs.DS 2026-05-08

ILP computes exact optima for shortest-path network design

Designing Capacitated Subnetworks for Shortest Path Routing

Simple heuristic of routing first then deactivating unused links stays close to the true optimum on practical instances.

abstract click to expand

In pursuit of higher energy efficiency in computer networks, one subfield of green traffic engineering aims at reducing the size of a network during times of low traffic, while still guaranteeing the ability to route all occurring demands. In this setting, we have to simultaneously solve a network design problem (choosing connections to deactivate) and a routing problem (routing paths in the active subnetwork, adhering to some routing protocol). Interestingly, there seems to be no available method to tackle the problem as a whole for the simplest (and still most commonly used) routing paradigm: shortest path routing. State-of-the-art methods either do not consider capacities, or assume that the routing paths should not change when deactivating network connections, or separate the problem into its two constituents, first solving the network design problem (using some estimators in lieu of the precise routing protocol) and only then the actual routing problem. In this paper, we present an algorithm to tackle the full combined problem exactly via a novel integer linear program, modeling dynamically changing shortest paths. To solve it, we need to devise a special-purpose column generation method. To speed up the solution process, we further propose additional provably strengthening constraints. Now having the means to yield true optimal solutions for (small) practical instances, we can for the first time give an in-depth experimental evaluation that includes the absolute quality intrinsic to the above simplifying algorithms. It turns out that the arguably simplest method--first computing a routing, fixing it, and turning off all superfluous connections--yields solutions surprisingly close to the true optimum in practice. When considering multiple different traffic demands, a recent traffic-oblivious approach (TOCA) performs best, while being comparatively straightforward to implement.

0

cs.DS 2026-05-08

Bilateral treewidth makes QBF evaluation fixed-parameter tractable

Bilateral Treewidth for QBF: Where Strategies and Resolution Meet

The new parameter unifies strategy branching with resolution steps to cover more quantified formulas than prior measures.

abstract click to expand

Treewidth is a well-studied decompositional parameter to measure the tree-likeness of a graph. While the propositional satisfiability problem (SAT) is known to be tractable when parameterized by the treewidth of the underlying primal graph, the evaluation of quantified Boolean formulas (QBFs) remains PSPACE-complete even on formulas of constant treewidth. Intuitively, this is because ordinary treewidth does not take into account the prefix of the QBF: it neither distinguishes between existential and universal variables, nor accounts for the order in which they are quantified. In the past, several weaker variants of treewidth have been devised to incorporate prefix-sensitive information. To establish tractability for QBFs under these notions, prior work has employed either strategy- or resolution-based techniques, thereby dividing the parameterized complexity landscape of QBF into two regimes that are incomparable in strength. We establish fixed-parameter tractability with respect to bilateral treewidth, a novel and strictly more powerful decompositional parameter that combines these rivaling approaches by simultaneously allowing for branching on strategies and performing Q-resolution. As in previous works in this direction, our algorithm assumes that a suitable tree decomposition is provided on the input.

0

cs.DS 2026-05-08

Matching bounds close gap for randomized online bidding

The Pareto Frontier of Randomized Learning-Augmented Online Bidding

Upper and lower bounds on consistency coincide for robustness at or above 2.885, fully determining the tradeoff.

abstract click to expand

Online bidding is a classical problem in online decision-making, with applications in resource allocation, hierarchical clustering, and the analysis of approximation algorithms. We study its randomized learning-augmented variant, where an online algorithm generates a sequence of random bids while leveraging predictions from an oracle. We provide analytical upper and lower bounds on the optimal consistency $C$ as a function of the robustness $R$, which match when $R \geq 2.885$, effectively closing the gap left by previous work. The key technical ingredient is the notion of a bidding function, a novel abstraction that provides a unified framework for the design and analysis of randomized bidding strategies. We complement our theoretical results with an experimental application of randomized bidding to the incremental median problem, demonstrating the applicability of our algorithm in practical clustering settings.

1 0

0

cs.DS 2026-05-08

Label correcting algorithms find nondominated temporal paths without monotonicity

Label Correcting Algorithms for the Multiobjective Temporal Shortest Path Problem

They use a path-length bound or sufficient conditions to recover every nondominated image in discrete-time multiobjective problems.

abstract click to expand

Given a directed, discrete-time temporal graph $G=(V,R)$, a start node $s\in V$, and $p\geq1$ objectives, the single-source multiobjective temporal shortest path problem asks, for each $v\in V$, for the set of nondominated images of temporal $s$-$v$-paths together with a corresponding efficient path for each image. A recent general label setting algorithm for this problem relies on two properties of the objectives - monotonicity and isotonicity. Monotonicity generalizes the nonnegativity assumption required by label setting methods for the classical additive single-objective shortest path problem on static graphs, while isotonicity ensures that the order of the objective values of two paths is preserved when both are extended by the same arc. In this paper, we study the problem without assuming monotonicity and/or isotonicity. A key difficulty in this setting is that zero-duration temporal cycles may need to be traversed an arbitrary finite number of times to generate all nondominated images. This motivates the study of a restricted problem variant in which a maximum admissible path length $K$ is imposed, and only paths containing at most $K$ arcs are considered. We develop general label correcting algorithms for this setting and establish several sufficient conditions under which such a bound is not required, implying that the algorithms compute all nondominated images.

0

cs.DS 2026-05-08

Glauber annealing converges to ε KL error in O(n^5 β²/ε) steps for Ising

Discrete Optimal Transport: Rapid Convergence of Simulated Annealing Algorithms

Discrete optimal transport bounds KL error by the action of the annealing path, giving polynomial rates for mean-field models.

abstract click to expand

We develop a discrete optimal transport framework for analyzing simulated annealing algorithms on finite state spaces. Building on the discrete Wasserstein metric introduced by Maas (J. Funct. Anal., 2011), we define a generalized discrete Wasserstein-2 distance and the associated notion of \emph{discrete action} for paths of probability measures on graphs. Using these tools, we establish non-asymptotic convergence guarantees for simulated annealing: the KL divergence between the algorithm's output and the target distribution is controlled by the discrete action of the annealing path. This can be viewed as the discrete counterpart of the action-based analysis of annealed Langevin dynamics in continuous spaces by Guo, Tao, and Chen (ICLR 2025). As applications, we analyze simulated annealing for two fundamental models in statistical physics. For the \emph{mean-field Ising model}, we show that annealed single-site Glauber dynamics achieves $\varepsilon$ error in KL divergence in $O(n^5\beta^2/\varepsilon)$ steps at \emph{any} inverse temperature $\beta \ge 0$. For the \emph{mean-field $q$-state Potts model}, we show that annealed $(q-1)$-block Glauber dynamics achieves $\varepsilon$ error in $\mathrm{poly}(n, \beta, 1/\varepsilon)$ steps for all $\beta \ge \beta_{\mathsf{s}}=q/2$, the regime where the disordered phase has completely lost stability. In both cases, the key technical contribution is a polynomial upper bound on the discrete action, obtained by exploiting the symmetry of the model to reduce the analysis to a low-dimensional projected chain.

0

cs.DS 2026-05-08

Online algorithms hit exact limit for independent sets in dense hypergraphs

Algorithmic Phase Transition for Large Independent Sets in Dense Hypergraphs

They reach the optimal ratio r to the 1 over r-1 and prove no online method can exceed it while identifying the precise maximum size.

abstract click to expand

We study the algorithmic tractability of finding large independent sets in dense random hypergraphs. In the sparse regime, much of the natural algorithms can be formulated within either the local or the low-degree polynomial (LDP) framework, and a rich literature has subsequently identified nearly sharp algorithmic thresholds within these classes by exploiting their stability. In the dense setting, however, the algorithmic paradigms are fundamentally different: they are online and thus need not be stable. Perhaps more crucially, even for the classical Erd\H{o}s-R\'enyi random graph $G(n,p)$, LDPs are conjectured to fail in the 'easy' regime accessible to online algorithms, thereby challenging their viability for dense models. Our focus is on two models: (i) finding large independent sets in dense $r$-uniform Erd\H{o}s-R\'enyi hypergraphs, and (ii) the more challenging problem of finding large $\gamma$-balanced independent sets in dense $r$-uniform $r$-partite hypergraphs, where the $i$-th coordinate of $\gamma\in\mathbb{Q}^r$ specifies the proportion of vertices from $V_i$ in the independent set. For both models, we pinpoint the size of the largest independent set and design online algorithms that achieve a multiplicative approximation factor of $r^{1/(r-1)}$ in the uniform and $(\max_i \gamma_i)^{-1/(r-1)}$ in the $r$-partite model. Furthermore, we establish matching algorithmic lower bounds, showing that these computational gaps are sharp: no online algorithms can breach these gaps.

0

cs.DS 2026-05-08

Attention coresets shrink to sqrt(d) exp(rho) size

Nearly Optimal Attention Coresets

A small subset of keys and values matches full softmax attention within epsilon for every query of norm at most rho.

abstract click to expand

We consider the problem of estimating the Attention mechanism in small space, and prove the existence of coresets for it of nearly optimal size. Specifically, we show that for any set of unit-norm keys and values $(K,V)$ in $\mathbb{R}^d$, there exists a subset $(K',V')$ of size at most $O({\sqrt{d} e^{\rho+o(\rho)}/\varepsilon})$ such that \[ \left\| \operatorname{Attn}(q,K,V)- \operatorname{Attn}(q,K',V') \right\| \le \varepsilon \] simultaneously for all queries whose norm is bounded by $\rho$. This outperforms the best known results for this problem. We also offer an improved lower bound showing that $\varepsilon$-coresets must have size $\Omega({\sqrt{d} e^{\rho}/\epsilon})$.

0

cs.DS 2026-05-07 Recognition

Balanced separators shrink to O(h sqrt(log h) sqrt(n)) for minor-free graphs

A Separator for Minor-Free Graphs Beyond the Flow Barrier

The construction breaks the flow-based limit and narrows the gap to the O(h sqrt(n)) conjecture of Alon, Seymour, and Thomas.

abstract click to expand

In 1990, Alon, Seymour, and Thomas gave the first balanced separator of size $O(h^{3/2}\sqrt{n})$ for any $K_h$-minor-free graph, which has had numerous algorithmic applications. They conjectured that the size of the balanced separator can be reduced to $O(h\sqrt{n})$, which is asymptotically tight. Two decades later, Kawarabayashi and Reed constructed a separator of size $O(h\sqrt{n} + f(h))$ based on the graph minor structure theorem, where $f(h)$ is an extremely fast-growing function typically seen in the structure theorem. Recently, Spalding-Jamieson constructed a separator of size $O(h\log h \log\log h \sqrt{n})$; the technique is rooted in concurrent flow-sparsest cut duality. Spalding-Jamieson's separator comes very close to $O(h\log h \sqrt{n})$, which is the barrier for techniques based on the flow-cut duality. In this work, we first observe that plugging in the recent padded decomposition by Filtser and Conroy into the flow-based algorithm of Korhonen and Lokshtanov yields a balanced separator of size $O(h\log h \sqrt{n})$, matching the flow barrier. This result motivates the question of whether the flow barrier can be broken, which would be a stepping stone toward resolving the conjecture of Alon, Seymour, and Thomas. The main result of our work is a positive answer to this question: we construct a balanced separator of size $O(h \sqrt{\log h} \sqrt{n})$. Surprisingly, perhaps, our algorithm is still based on the iterative framework of Alon, Seymour, and Thomas, although a key component of their algorithm within this framework, called the neighborhood bound, was shown to be tight. Our new idea is to incorporate a low-diameter decomposition into the framework, which allows us to reduce the neighborhood bound by a factor of $h$, at the cost of a factor $\log h$. As a result, we improve the $\sqrt{h}$ factor to $\sqrt{\log h}$ in the final separator's size.

0

cs.DS 2026-05-07

Balanced separator for minor-free graphs improved to O(h sqrt(log h) sqrt n)

A Separator for Minor-Free Graphs Beyond the Flow Barrier

The bound breaks the O(h log h sqrt n) flow barrier and moves closer to the long-standing O(h sqrt n) conjecture.

abstract click to expand

In 1990, Alon, Seymour, and Thomas gave the first balanced separator of size $O(h^{3/2}\sqrt{n})$ for any $K_h$-minor-free graph, which has had numerous algorithmic applications. They conjectured that the size of the balanced separator can be reduced to $O(h\sqrt{n})$, which is asymptotically tight. Two decades later, Kawarabayashi and Reed constructed a separator of size $O(h\sqrt{n} + f(h))$ based on the graph minor structure theorem, where $f(h)$ is an extremely fast-growing function typically seen in the structure theorem. Recently, Spalding-Jamieson constructed a separator of size $O(h\log h \log\log h \sqrt{n})$; the technique is rooted in concurrent flow-sparsest cut duality. Spalding-Jamieson's separator comes very close to $O(h\log h \sqrt{n})$, which is the barrier for techniques based on the flow-cut duality. In this work, we first observe that plugging in the recent padded decomposition by Filtser and Conroy into the flow-based algorithm of Korhonen and Lokshtanov yields a balanced separator of size $O(h\log h \sqrt{n})$, matching the flow barrier. This result motivates the question of whether the flow barrier can be broken, which would be a stepping stone toward resolving the conjecture of Alon, Seymour, and Thomas. The main result of our work is a positive answer to this question: we construct a balanced separator of size $O(h \sqrt{\log h} \sqrt{n})$. Surprisingly, perhaps, our algorithm is still based on the iterative framework of Alon, Seymour, and Thomas, although a key component of their algorithm within this framework, called the neighborhood bound, was shown to be tight. Our new idea is to incorporate a low-diameter decomposition into the framework, which allows us to reduce the neighborhood bound by a factor of $h$, at the cost of a factor $\log h$. As a result, we improve the $\sqrt{h}$ factor to $\sqrt{\log h}$ in the final separator's size.

0

cs.DS 2026-05-07

Algorithms compute shortest unique substrings in O(n log σ/√log n) time

Faster Algorithms for Shortest Unique or Absent Substrings

Decomposing candidates by length and period and reducing to geometry beats the linear-time suffix-tree method for small alphabets.

abstract click to expand

We revisit two well-known algorithmic problems on strings: computing a shortest unique substring (SUS) and a shortest absent substring (SAS) of a string $S$ of length $n$. Both problems admit folklore $\mathcal{O}(n)$-time solutions using the suffix tree of $S$. However, for small alphabets, this complexity is not necessarily optimal in the word RAM model, where a string of length $n$ over alphabet $[0,\sigma)$ can be stored in $\mathcal{O}(n \log \sigma/\log n)$ space and read in $\mathcal{O}(n \log \sigma/\log n)$ time. We present an $\mathcal{O}(n \log \sigma/\sqrt{\log n})$-time algorithm for computing a SUS of $S$. This algorithm decomposes the problem according to the length and the period of the sought substring and uses several tools and techniques, such as synchronizing sets, the analysis of runs, and wavelet trees, to reduce the computation of a SUS to a simple geometric problem. Further, we adapt this algorithm and combine it with an efficient construction of de Bruijn sequences in order to obtain an $\mathcal{O}(n \log \sigma/\sqrt{\log n})$-time algorithm for computing a SAS of $S$.

0

cs.DS 2026-05-07

Deterministic structure matches randomized Online Orthogonal Vectors

Online Orthogonal Vectors Revisited

It improves two-decade-old bounds in moderate dimensions and refutes a hardness conjecture via a structure-versus-randomness split.

abstract click to expand

We prove new upper and lower bounds for the Online Orthogonal Vectors Problem ($\mathsf{OnlineOV}_{n,d}$). In this problem, a preprocessing algorithm receives $n$ vectors $x_1,\ldots,x_n\in\{0,1\}^d$ and constructs a data structure of size $S$. A query algorithm subsequently receives a query vector $q\in\{0,1\}^d$ and in time $T$ decides whether $q$ is orthogonal to any of the input vectors $x_i$. We design a new deterministic data structure for $\mathsf{OnlineOV}_{n,d}$. In low dimensions ($d = c \log n$), our data structure matches the performance of the best known randomized algorithm due to Chan [SoCG 2017]. Furthermore, in moderate dimensions ($d=n^{\varepsilon}$), we give the first improvement since Charikar, Indyk and Panigrahy [ICALP 2002]. Along the way, we give the first deterministic refutation of a conjecture on the hardness of $\mathsf{OnlineOV}$ posed by Goldstein, Lewenstein and Porat [ISAAC 2017]. This data structure also extends to a number of problems, including Partial Match, Orthogonal Range Search, and DNF Evaluation. We use a novel structure-versus-randomness decomposition to design our algorithm. Under the Non-Uniform Strong Exponential Time Hypothesis, we also prove arbitrarily large polynomial space lower bounds for any $\mathsf{OnlineOV}$ data structure with sublinear query time even with computationally unbounded preprocessing. These lower bounds extend to several other problems, including Polynomial Evaluation, Partial Match, Orthogonal Range Search, and Approximate Nearest Neighbors. We also prove similar lower bounds for $\mathsf{3-SUM}$ with preprocessing under the Non-Uniform Hamiltonian Path Conjecture.

0

cs.DS 2026-05-07

Beam search on meshes yields quadratic error decay for subset sum

Robust Inverse Quadratic Error Decay with Meshing and Beam Search for Random Subset Sum

The linearithmic algorithm trims candidates to width w and reduces expected error as O(B over n w squared) under standard assumptions.

abstract click to expand

The Subset Sum Problem is a fundamental NP-complete problem in cryptography and combinatorial optimization, with many real-world applications. The Random Subset Sum Problem (RSSP) is a more applicable version of subset sum, where numbers are drawn from some i.i.d input distribution. We present an algorithm that, with probability $1-\delta$, constructs the same $O(B/w)$ mesh as Da Cunha et al. (2023), while trimming to $w$ elements throughout and running in $O(w\log w)$ time. Then, we present a novel beam search heuristic running in linearithmic time w.r.t list size $n$ and beam width $w$ using the mesh that gives an expected error of $O\!\left(\frac{B}{nw^2}\right)$ under a standard mean-field assumption with equal standard deviation, demonstrating the practical effectiveness of meshing to achieve error decay. The algorithm is empirically robust to multiple input distributions and can naturally extend to variants with simple changes to the scoring heuristic, establishing a new practical baseline for robust subset sum error decay and $\epsilon$-approximation theory.

0

cs.DS 2026-05-07

Pruning hits tight 1-1/e bound for monotone submodular selection

Submodular Ground-Set Pruning: Monotone Tightness and a Non-Monotone Separation

Non-monotone cases receive 1/2-ε containment algorithms that beat direct optimization hardness

abstract click to expand

Large-scale subset selection asks for a small useful set of examples, features, sensors, seed users, or context passages from an enormous ground set. Submodular maximization is a canonical model for such diminishing-returns problems, but rapidly growing datasets make even linear-time algorithms ever costlier. We study \emph{containment pruning}: first reduce the ground set to a smaller core $P$, then require that $P$ contain a near-optimal feasible solution for every downstream budget up to~$k$. Prior work has formulated many heuristics, but the theoretical limits of this preprocessing problem are largely unknown. For monotone submodular objectives, we prove that $1-1/e$ is tight: greedy achieves this containment factor, and no algorithm can beat it even with a larger pruning budget. For non-monotone objectives, we give the first$1/2-\varepsilon$ containment algorithms under cardinality constraints and extend the approach to knapsack constraints. This $1/2$ factor exceeds the best known algorithmic ratio and the known hardness threshold for non-monotone maximization, showing that pruning can be provably easier than optimization. Empirically, pruning lets an exact IP solver run on the reduced MaxCut instance with a ${\approx}620\times$ speedup, and proof-of-concept experiments on LLM context selection demonstrate the utility of non-monotone submodular proxies and our proposed containment algorithms.

0

cs.DS 2026-05-06

One-pass linear-time algorithm for suffixient arrays

Constructing Suffixient Arrays Revisited

Processes suffix array, LCP and reverse BWT in a single scan without extra logarithmic cost.

abstract click to expand

Recently, Cenzato et al.\ proposed a new text index, called the \emph{suffixient array}, which is a subset of the suffix array and supports locating a single pattern occurrence or finding its maximal exact matches (MEMs), assuming random access to the input text $T[1..n]$ is available. They show that, given the suffix array, the longest common prefix array, and the Burrows--Wheeler transform (BWT) of the reverse of $T[1..n]$ over an alphabet $\{1,\ldots,\sigma\}$, a suffixient array can be constructed in linear time. However, their construction algorithms require multiple scans of these arrays. When restricted to a single pass over the arrays, they present an alternative construction algorithm running in $O(n + \overline{r} \log \sigma)$ time, where $\overline{r}$ is the number of runs in the BWT of the reversed text. In this paper, we present a new one-pass algorithm that constructs a suffixient array in linear time under the standard RAM model.

0

cs.DS 2026-05-06

Refined segments speed up iterative PBWT queries

Faster Iterative φ Queries on the Positional BWT

A constant-overlap decomposition of haplotypes yields faster or smaller indexes for chains of predecessor lookups when haplotypes are fewer.

abstract click to expand

The Positional Burrows-Wheeler Transform (PBWT) is a fundamental data structure for the efficient representation and analysis of large-scale haplotype panels. For a panel of $h$ sequences $\{S_1, \dots, S_h\}$ over $m$ sites, a key operation is the $\phi_j(i)$ query, which returns the haplotype index immediately preceding $S_i$ in co-lexicographic order at site $j$. Efficient support for $k$ iterative queries $\phi^1, \dots, \phi^k$ is essential for haplotype matching and variation analysis. In this work, we introduce a simple and novel decomposition scheme that decomposes each haplotype row into sub-intervals, called refined segments, within which a haplotype's co-lexicographic predecessor for the sites remains unchanged. We show that refined segments satisfy two key properties: (i) each segment $[b,e]$ associated with $S_i$ overlaps with at most a constant number of segments of $S_{\phi_e(i)}$, and (ii) the total number of segments is bounded by $O(\tilde{r} + h)$, where $\tilde{r}$ denotes the number of runs in the PBWT. Building on this decomposition, we present two space-time tradeoffs for supporting $k$ iterative $\phi$ queries: (i) a structure using $O((\tilde{r} + h)\log n)$ bits of space that answers $k$ iterative queries in $O(\log \log_w \min(m,h) + k)$ time, where $n = m \cdot h$, and (ii) a more compact structure using $O(\tilde{r} \log h + h \log n)$ bits of space that supports queries in $O(k \log \log_w h)$ time. Prior to our work, supporting these queries required $O((\tilde{r} + h)\log n)$ bits of space and $O(k \cdot \log \log_w m)$ time. Our second tradeoff is expected to be effective in practice for modern genomic datasets, where the number $h$ of haplotypes is typically much smaller than the number $m$ of sites.

0

cs.DS 2026-05-06 3 theorems

Zonotope containment gets O(√d) approximation algorithm

Nearly-Tight Bounds for Zonotope Containment and Beyond

Sampling method nearly matches Ω(√d/log d) lower bound and reaches optimal under sparsification conjecture

abstract click to expand

We investigate the convex-body containment problem $\max\{s >0 : s Z \subseteq Q\}$, where the outer body $Q \subseteq \mathbb R^d$ is described by a membership oracle and the inner body $Z \subseteq \mathbb R^d$ is a zonotope. Our main result is a sampling-based $O(\sqrt{d})$-approximation algorithm for this problem that almost matches the lower bound of $\Omega(\sqrt{d/\log d})$ by Khot and Naor in the oracle model. Assuming zonotopes can be sparsified by a linear number of generators, which is referred to as Talagrand conjecture, our approach attains the optimal approximation factor of $\Theta(\sqrt{d/\log d})$. Our second main result is a proof of Talagrand's conjecture for $\Delta$-modular zonotopes whenever $\Delta$ is constant. Those zonotopes are of the form $Z = \{ Wx \colon \| x\|_\infty \leq 1\}$ where the non-zero $d \times d$ sub-determinants of $W$ are between $1$ and $\Delta$. This result establishes a connection between zonoid sparsification and spectral sparsification of Batson, Spielman and Srivastava. We complement these results with a universal $\Omega(\sqrt{d/\log d})$ lower bound holding for all zonotopes. Finally, we consider containment problems $\max\{s >0 : s K \subseteq Q\}$, for general convex bodies $K \subseteq \mathbb R^d$. A result of Nasz\'odi on approximating $K \subseteq \mathbb R^d$ by a polytope implies a $\Theta(d/\log d)$ approximation algorithm in polynomial time. We show the tightness of this approximation factor in the oracle model via a reduction to the circumradius computation. Our lower bound holds for centrally symmetric convex sets, implying that Barvinok's optimal $O(\sqrt{d})$-approximation of a centrally symmetric convex body by a polytope with a polynomial number of vertices cannot be computed in polynomial time.

0

cs.DS 2026-05-06

Algorithm finds matroid basis in n^{3/7} parallel rounds

An widetilde{O} (n^{3/7}) Round Parallel Algorithm for Matroid Bases

Cuts adaptive query rounds for any matroid by analyzing multi-element dependencies in random circuits.

abstract click to expand

We study the parallel (adaptive) complexity of the classic problem of finding a basis in an $n$-element matroid, given access via an \emph{independence oracle}. In this model, the algorithm may submit polynomially many independence queries in each round, and the central question is: how many rounds are necessary and sufficient to find a basis? Karp, Upfal, and Wigderson (FOCS~1985, JCSS~1988; hereafter KUW) initiated this study, showing that $O(\sqrt{n})$ adaptive rounds suffice for any matroid, and that $\widetilde\Omega(n^{1/3})$ rounds are necessary even for partition matroids. This left a substantial gap that persisted for nearly four decades, until Khanna, Putterman, and Song (FOCS~2025; hereafter KPS) achieved $\widetilde O(n^{7/15})$ rounds, the first improvement since~KUW. In this work, we make another conceptual advance beyond KPS, giving a new algorithm that finds a matroid basis in $\widetilde O(n^{3/7})$ rounds. We develop a structural and algorithmic framework that brings a new lens to the analysis of random circuits, moving from reasoning about individual elements to understanding how dependencies span multiple elements simultaneously.

0

cs.DS 2026-05-06

No online algorithm finds common induced subgraphs beyond 2 log n

Optimal Hardness of Online Algorithms for Large Common Induced Subgraphs

The largest possible reaches 4 log n but online methods are provably limited to 2, shown via overlap gap property.

abstract click to expand

We study the problem of efficiently finding large common induced subgraphs of two independent Erd\H{o}s--R\'enyi random graphs $G_1, G_2 \sim \mathbb{G}(n,1/2)$. Recently, Chatterjee and Diaconis showed that the largest common induced subgraph of $G_1$ and $G_2$ has size $(4-o(1))\log_2 n$ with high probability. We first show that a simple greedy online algorithm finds a common induced subgraph of $G_1$ and $G_2$ of size $(2-o(1)) \log_2 n$ with high probability. Our main result shows that no online algorithm can find a common induced subgraph of $G_1$ and $G_2$ of size at least $(2+\varepsilon) \log_2 n$ with probability bounded away from $0$ as $n \to \infty$. Together, these results provide evidence that this problem exhibits a computation-to-optimization gap. To prove the impossibility result, we show that the solution space of the problem exhibits a version of the (multi) overlap gap property (OGP), and utilize an interpolation argument recently developed by Gamarnik, Kizilda\u{g}, and Warnke that connects OGP and online algorithms.

0

cs.DS 2026-05-06

Parallel algorithms cut depth below sqrt(n) for reachability on dense digraphs

Parallel Reachability and Shortest Paths on Non-sparse Digraphs: Near-linear Work and Sub-square-root Depth

Near-linear work suffices for single-source reachability and shortest paths once edges exceed n^{1+o(1)}, improving the prior Omega(sqrt(n))

abstract click to expand

We present parallel algorithms for computing single-source reachability and shortest paths on directed $n$-vertex $m$-edge graphs using near-linear $\tilde{O}(m)$ work and $o(\sqrt{n})$ depth whenever $m\ge n^{1+o(1)}$. At the extreme of $m=\Omega(n^{2})$, our reachability and shortest path algorithms have depth only $n^{0.136}$ and $n^{0.25+o(1)}$, respectively. The state-of-the-art parallel algorithms with near-linear work for both problems require $\Omega(\sqrt{n})$ depth in all density regimes.

0

cs.DS 2026-05-06

Randomized algorithm approximates TV distance of product mixtures

On Computing Total Variation Distance Between Mixtures of Product Distributions

Achieves (1±ε) multiplicative error for k-component mixtures over n dimensions in poly((nq)^k,1/ε) time

abstract click to expand

We study the problem of approximating the total variation distance between two mixtures of product distributions over an $n$-dimensional discrete domain. Given two mixtures $\mathbb{P}$ and $\mathbb{Q}$ with $k_1$ and $k_2$ product distributions over $[q]^n$, respectively, we give a randomized algorithm that approximates $d_{\mathrm{TV}}\left({\mathbb{P}},{\mathbb{Q}}\right)$ within a multiplicative error of $(1\pm \varepsilon)$ in time $\mathrm{poly}((nq)^{k_1+k_2},1/\varepsilon)$. We also study the special case of mixtures of Boolean subcubes over $\{0,1\}^n$. For this class, we give a deterministic algorithm that exactly computes the total variation distance in time $\mathrm{poly}(n,2^{O(k_1+k_2)})$, and show that exact computation is $\#\mathsf{P}$-hard when $k_1+k_2=\Theta(n)$.

0

cs.DS 2026-05-06

Two open problems proven XNLP-complete in scheduling and graphs

The Parameterized Complexity of Scheduling with Precedence Delays: Shuffle Product and Directed Bandwidth

Results imply hardness for min and max delay scheduling parameterized by DAG width or delay value, and resolve trees case for bandwidth.

abstract click to expand

In this paper, we study the parameterized complexity of several variants of scheduling with precedence constraints between jobs. Namely, we consider the single machine setting with delay values on top of the precedence constraints. Such scheduling problems are related to several decades-old problems with open parameterized complexity status, notably Shuffle Product and Directed Bandwidth. We obtain XNLP-completeness results for both problems, and derive implications to scheduling with minimum (resp. maximum) delays parameterized by the width of the directed acyclic graph giving the precedence constraints, and/or by the maximum delay value in the input. Regarding Directed Bandwidth, we also settle the case of trees by showing XNLP-completeness parameterized by the target value. Beyond these results, we believe that Shuffle Product is an unusual and promising addition to the list of XNLP-complete problems.

0

cs.DS 2026-05-06

Optimal polytree found in O((2+ε)^n) time for constant in-degree

Exact and Approximate Algorithms for Polytree Learning

Beats prior O(3^n) exact bound and delivers polynomial-time approximations within factor k or 2 of optimal.

abstract click to expand

Polytrees are a subclass of Bayesian networks that seek to capture the conditional dependencies between a set of $n$ variables as a directed forest and are motivated by their more efficient inference and improved interpretability. Since the problem of learning the best polytree is NP-hard, we study which restrictions make it more tractable by considering for example in-degree bounds, properties of score functions measuring the quality of a polytree, and approximation algorithms. We devise an algorithm that finds the optimal polytree in time $O((2+\epsilon)^n)$ for arbitrarily small $\epsilon > 0$ and any constant in-degree bound $k$, improving over the fastest previously known algorithm of time complexity $O(3^n)$. We further give polynomial-time algorithms for finding a polytree whose score is within a factor of $k$ from the optimal one for arbitrary scores and a factor of $2$ for additive ones. Many of the results are complemented by (nearly) tight lower bounds for either the time complexity or the approximation factors.

0

cs.DS 2026-05-06

Vertex pruning counts balanced bicliques 636 times faster

Counting Small Balanced (p,q)-bicliques in Signed Bipartite Graphs

In signed bipartite graphs a direct-enumeration method with early pruning beats adapted baselines on real data for small p and q.

abstract click to expand

Two disjoint sets of entities and their relationship can be modelled as a bipartite graph. Real-life examples include drug-target interaction in biological networks, user-item relationships in e-commerce networks, etc. Motif-based analysis is essential for understanding the structure of large-scale networks, and bipartite graphs are no exception. In contrast to unsigned graphs, motif analysis in signed bipartite graphs has received limited attention. The smallest non-trivial motif in a signed bipartite graph is a balanced (2,2)-biclique, often called a balanced butterfly, which captures only local patterns and cannot reveal higher-order relationships. Bipartite motifs have been studied in the literature in the context of signed bipartite graphs, such as maximal biclique, bitruss, and so on. None of these works addresses bipartite motifs with fixed-sized vertex sets, which are often relevant in practical situations. In this work, we study the balanced (p,q)-biclique counting problem for small values of p and q. As a baseline, we first adapt and extend the state-of-the-art BCList++ algorithm for unsigned bipartite graphs to incorporate edge signs, which we call SBCList++. We then propose two efficient algorithms: BBWC, a wedge-centric approach that enforces balance constraints during enumeration, and BBVP, a vertex-based pruning approach that directly enumerates feasible vertex sets. Extensive experiments on large real-world datasets demonstrate that the vertex-based pruning algorithm, BBVP, significantly outperforms the baseline, achieving an average speedup of 636$\times$ over SBCList++ (where p=q=3).

0

cs.DS 2026-05-06

O(n²) algorithm finds optimal diameter partitions for every size

An Optimal Algorithm for Cardinality-Constrained Diameter Partitioning

It proves a matching lower bound and computes all cardinalities together by solving a coloring problem on the maximum spanning tree.

abstract click to expand

Cardinality-constrained diameter partitioning asks for a partition of $n$ items into two classes of prescribed sizes that minimizes the larger of the two class diameters. We give an $O(n^2)$ algorithm and a matching $\Omega(n^2)$ lower bound if we can only query the weight between two elements. The algorithm computes the optimum for every cardinality simultaneously, improving Avis's $O(n^2\log n)$. The reduction is to a bottleneck 2-coloring problem on the maximum spanning tree, solved by a standard tree DP. For a single cardinality with Euclidean weights, we obtain a subquadratic time algorithm in any fixed dimension.

0

cs.DS 2026-05-06

Low-dimensional embeddings violate half of triplet constraints

Provable Accuracy Collapse in Embedding-Based Representations under Dimensionality Mismatch

Any representation using dimension below a fixed fraction of the ground-truth D must fail on at least 50 percent of distance comparisons.

abstract click to expand

Embedding-based representations in Euclidean space $\mathbb{R}^d$ are a cornerstone of modern machine learning, where a major goal is to use the \emph{smallest dimension} that faithfully captures data relations. In this work, we prove sharp dimension--accuracy tradeoffs and identify a fundamental information-theoretic limitation: unless the embedding dimension $d$ is chosen close to the ground-truth dimension $D$, accuracy undergoes a sudden collapse. Our main result shows that this phenomenon arises even in standard contrastive learning settings, where supervision is limited to a set of $m$ anchor--positive--negative triplets $(i,j,k)$ encoding distance comparisons $\mathrm{dist}(i,j) < \mathrm{dist}(i,k)$. Specifically, given triplets realizable by an unknown ground-truth embedding in $D$ dimensions, we prove that there exists constant $c < 1$, such that \emph{every embedding of dimension at most $cD$ violates half of the triplets}, yielding accuracy as low as a trivial one-dimensional solution that ignores the input. We complement our information-theoretic bounds with strong computational hardness results: under the Unique Games Conjecture, even if the given triplets are nearly realizable in $D=1$ dimension, no polynomial-time algorithm -- \textit{regardless of its dimension} -- can achieve accuracy above the trivial $50\%$ baseline.

0

cs.DS 2026-05-05

Dynamic data structures answer long-path queries in polylog time

Dynamic Detours

For fixed k they support paths of length at least k or detours longer by k and even or odd length paths with 2 to the O of k cubed times log

abstract click to expand

Fix a parameter $k\in \mathbf{N}$. We give dynamic data structures that for a fully dynamic undirected graph $G$, updated over time by edge insertions and edge deletions, can answer the following queries: - Long $(u,v)$-path: Given $u,v\in V(G)$, is there a path from $u$ to $v$ of length at least $k$? - Long $(u,v)$-detour: Given $u,v\in V(G)$, is there a path from $u$ to $v$ of length at least $\text{dist}_G(u,v)+k$? - Even/odd $(u,v)$-path: Given $u,v\in V(G)$, is there a path from $u$ to $v$ of even/odd length? The amortized time of executing an update or answering a query is $2^{O(k^3)} \log n + O(\log^2 n \log^2 \log n)$ in the first two cases, and $O(\log^2 n \log^2 \log n)$ in the last, where $n$ is the number of vertices of $G$. The first result is in sharp contrast with known conditional lower bounds for reporting paths of length at most $k$. Specifically, there is no data structure supporting queries about $(u,v)$-paths of length at most two in time $n^{o(1)}$ unless the Triangle Conjecture fails. Our main technical contribution is a mechanism of "delayed edge insertion" that works locally on the level of biconnected components.

0

cs.DS 2026-05-05

Poisson process matches tight submodular approximation

A Poisson Process for Submodular Maximization

The method reaches the (1-1/e) guarantee for matroid-constrained maximization without discretization or rounding.

abstract click to expand

We study the problem of maximizing a monotone submodular function subject to a matroid independence constraint. For more than a decade, a rich body of work has studied this problem. Initially, a tight approximation of $ (1-\frac{1}{e})$ was given using the continuous greedy algorithm [Calinescu-Chekuri-Pal-Vondr{\'a}k STOC`2008] and later non-oblivious local search techniques were able to match this tight approximation guarantee [Filmus-Ward FOCS`2012] and [Buchbinder-Feldman FOCS`2024]. We propose a new and remarkably simple approach to this problem that is based on a stochastic Poisson process. Our approach matches the tight $ (1-\frac{1}{e})$ approximation guarantee and it differs from the known two techniques since it does not require discretization or rounding while performing very few single element swaps. We also present applications of our approach and obtain fast algorithms for submodular welfare maximization, and for the general and separable assignment problems.

0

cs.DS 2026-05-05

Similarity merges bound the possible ranks of any chosen subset

Ranking with Partitioning

Four graph-based optimization problems compute the highest and lowest ranks a special group can occupy when similar items are allowed to be,

abstract click to expand

Given an undirected graph representing similarities between a set of items and an additive measure evaluating the items, we treat the position of a special subset of items in an ordinal ranking through a collection of combinatorial optimization problems in which items may be combined if they are similar. The objective for these problems is to either maximize or minimize the absolute or relative rank of the special subset, with a meta-goal of assessing the robustness of the rank, even in the presence of a well-defined criterion. We classify the computational complexity of all four problems, mostly finding worst-case hardness, then find exact and approximate solutions to special cases and variants of the problems. These structured cases are inspired by several real-world examples and may be used to assess commonly cited facts across disparate domains, as we demonstrate for sources of greenhouse gas emissions that contribute to climate change.

0

cs.DS 2026-05-05 2 theorems

O(k^33) kernel for deleting to proper interval graphs or trees

A Polynomial Kernel for Vertex Deletion to the Scattered Class of Proper Interval Graph and Trees

The vertex-deletion problem whose components must be proper interval graphs or trees reduces to an equivalent instance of size O(k to the 33

abstract click to expand

Vertex deletion to hereditary graph class is well-studied in parameterized complexity. Vertex deletion to the scattered graph classes has gained attention in recent years. In this paper, we consider (Proper-Interval, Tree)-Vertex Deletion, the input to which is an undirected graph $G = (V, E)$ and an integer $k$. The goal is to pick a set $X \subseteq V(G)$ of at most $k$ vertices such that $G - X$ is a simple graph and every connected component of $G - X$ is a proper interval graph or a tree. When parameterized by the solution size $k$, (Proper-Interval, Tree)-Vertex Deletion has been proved to be fixed-parameter tractable by Jacob et al. [JCSS-2023, FCT-2021]. In this paper, we consider this problem from the perspective of polynomial kernelization. We provide a first nontrivial polynomial kernel for (Proper-Interval, Tree)-Vertex Deletion, with $O(k^{33})$ vertices.

0

cs.DS 2026-05-05 3 theorems

Standard DFS and BFS recognize several graph classes

On the power of standard DFS and BFS

Single or double traversals suffice for trivially perfect, split, and proper interval graphs by checking pattern-avoiding orderings.

abstract click to expand

It is well-known since the seventies of last century that Depth First Search (DFS) can be used to compute strongly connected components [RE. Tarjan. SIAM Journal on Computing, 1972] and Breadth First Search (BFS) can be used to compute distance in graphs [GY. Handler. Transportation Science, 1973]. We furthermore demonstrate that these standard graph searches are powerful enough to recognize and certify several well-structured graph classes. Specifically, we provide a single DFS approach for recognizing and certifying trivially perfect graphs that is significantly simpler than previous methods using [FPM. Chu. Information Processing Letters, 2008]. We further show that a single BFS can recognize split graphs and bipartite chain graphs, and we improve upon the triple LexBFS algorithm for proper interval graphs [DG. Corneil. Discrete Applied Mathematics, 2004] by proposing a two consecutive BFS recognition scheme. These results are underpinned by characterizations using vertex orderings that avoid specific patterns [L. Feuilloley, M. Habib. SIAM Journal on Discrete Mathematics, 2021]. Finally, we provide a structural study of connected proper interval graphs, proving that their characterizations via special orderings are unique up to reversal and the permutation of true twins.

0

cs.DS 2026-05-05 2 theorems

2-fault replacement paths reduce to single-source ones

Undirected Replacement Paths: Dual Fault Reduces to Single Source

Tight weight-preserving reduction in undirected graphs gives matching algorithms and lower bounds

abstract click to expand

Given a graph and two fixed vertices $s$ and $t$, the Replacement Path Problem (RP) is to compute for every edge $e$, the distance between $s$ and $t$ when $e$ is removed. There are two natural extensions to RP: (1) Single Source Replacement Paths (SSRP): Given a graph $G$ and a source node $s$, compute for every vertex $v$ and every edge $e$ the $s$-$v$ distance in $G \setminus \{e\}$. That is, we do not fix the target anymore. (2) $2$-Fault Replacement Paths (2-FRP): Given a graph $G$ and two nodes $s$ and $t$, compute for every pair of edges $e, e'$ the $s$-$t$ distance in $G \setminus \{e, e'\}$. That is, we consider two failures instead of one. Previously, there was no known reduction between SSRP and 2-FRP. It seemed plausible that 2-FRP would be computationally harder because there are no settings where 2-FRP admits a faster algorithm than SSRP. In directed unweighted graphs there is a provable gap in complexity, and in undirected graphs many of the known 2-FRP algorithms in a variety of settings are much slower than those for SSRP in the same setting. The main contribution of this paper is a tight reduction from undirected $2$-FRP to undirected SSRP, showing that contrary to prior intuition, 2-FRP is not harder than SSRP. As our reduction is weight-preserving, we obtain the first algorithms for $2$-FRP that match the best-known runtimes for SSRP: (1) $\tilde{O}(M n^{\omega})$ for weights in $[1, M]$ [GVW19], improving upon $O(Mn^{2.87})$ [CZ24]; (2) $n^3/2^{\Omega(\sqrt{\log n})}$ for weights in $[1, \text{poly}(n)]$ [GVW19], improving over the previous $n^3\text{polylog}(n)$ running time [VWWX22]; (3) $\tilde{O}(mn^{1/2}+n^{2})$ combinatorial time for unweighted graphs [CC19], and more generally for rational weights in $[1, 2]$ [CM20], improving upon $\tilde{O}(n^{3-1/18})$ [CZ24]. We complement these upper bounds with tight lower bounds under fine-grained hypotheses.

0

cs.DS 2026-05-04

The paper gives a linear-time algorithm to find a central vertex in 1/2-hyperbolic graphs…

A fine-grained dichotomy for the center problem on Gromov hyperbolic graphs

Linear-time algorithm for the center problem on 1/2-hyperbolic graphs, with a conditional lower bound ruling it out for 1-hyperbolic graphs.

abstract click to expand

A vertex in a graph is called central if it minimizes its maximum distance to the other vertices. The radius of a graph $G$ is the largest distance between a central vertex and the other vertices, and it is denoted by $rad(G)$. In the center problem, we are asked to find a central vertex. We study the fine-grained complexity of the center problem on graphs with small Gromov hyperbolicity. Roughly, the Gromov hyperbolicity of a graph represents how close, locally, it is to a tree, from a metric point of view. It has applications in the design of approximation algorithms. In particular, there is a linear-time algorithm that for every $\delta$-hyperbolic graph $G$ outputs some vertex at distance at most $rad(G) + 5\delta$ to the other vertices [Chepoi et al, SoCG'08]. However, a linear-time algorithm for computing a central vertex is known only for $0$-hyperbolic graphs, whereas its existence was ruled out for $2$-hyperbolic graphs under the Hitting Set Conjecture of [Abboud et al, SODA'16]. Our main contribution in the paper is a linear-time algorithm for computing a central vertex in the class of $\frac 1 2$-hyperbolic graphs. Furthermore, we rule out the existence of such an algorithm for $1$-hyperbolic graphs, under the Hitting Set Conjecture, thus completely settling all the cases left open.

0

cs.DS 2026-05-04

Derandomization yields first poly-time randomized k-server algorithm

Randomized k-server in polynomial time

O(log k) random bits keep polynomial configurations on trees, delivering polylog ratio on arbitrary metrics.

abstract click to expand

We study the design of computationally efficient randomized algorithms for the $k$-server problem. Existing randomized algorithms with the best known competitive ratios are, on the one hand, inherently implicit and, on the other hand, employ a rounding scheme that maintains a distribution over exponentially many configurations. In this work, we introduce a derandomization framework that transforms any randomized $k$-server algorithm on a hierarchically separated tree into one that uses only $O(\log k)$ random bits for request sequences of arbitrary length; hence maintaining a distribution over only polynomially many server configurations. Leveraging this black-box derandomization, we obtain the first polynomial-time randomized $k$-server algorithm on arbitrary $n$-point metrics with a polylogarithmic competitive ratio. Our results also have implications for the advice complexity of the $k$-server problem.

0

cs.DS 2026-05-04

Alpha-orderings unify two algorithms for symmetric submodular minimization

A Unified Approach to Minimizing Symmetric Submodular Functions

A single parameter connects minimum adjacency and minimum degree orderings and produces an O(n cubed) contraction procedure.

abstract click to expand

Symmetric submodular function minimization admits purely combinatorial algorithms using special orderings of the ground set. Extending the minimum-cut algorithm of Nagamochi and Ibaraki (1992), Queyranne (1998) showed that the maximum adjacency ordering yields a pendent pair, which can be used to find a nontrivial minimizer. Nagamochi (2010) later introduced the minimum degree ordering, which yields a flat pair and leads to the identification of extreme sets. Despite the apparent similarity between these two algorithms, their connection remained unclear. In this paper, we introduce yet another ordering called minimum capacity ordering, and extend it to a one-parameter family of orderings, called $\alpha$-orderings, that unifies these two previously known orderings. We prove a general inequality for $\alpha$-orderings, and our framework recovers the known pendent-pair and flat-pair results as special cases, corresponding to $\alpha = -1$ and $\alpha = 1$, respectively. For each $\alpha \in [-1, 1]$, the last two elements of an $\alpha$-ordering form a contractible pair, i.e., a pair whose contraction preserves the existence of a nontrivial minimizer, which leads to a contraction algorithm that finds a nontrivial minimizer of a symmetric submodular function in $O(n^3)$ oracle calls, where $n$ is the cardinality of the ground set. In addition, we discuss the ranges of $\alpha$ that ensure $\alpha$-ordering to obtain these special pairs.

0