Asymptotically faster algorithms for recognizing $(k,\ell)$-sparse graphs
2026-04-14 • Data Structures and Algorithms
Data Structures and AlgorithmsDiscrete Mathematics
AI summaryⓘ
The authors study a special type of graph called a $(k,\ell)$-sparse graph, important in areas like rigidity theory. They focus on the problem of quickly deciding if a graph fits this type and, if not, finding where it fails. Previous methods were slower for some parameter ranges, so the authors developed new algorithms that run much faster, close to linear time in many cases. Their approach uses techniques like orientation of edges, connectivity problems, and divide-and-conquer strategies. These algorithms also provide evidence sets that explain why a graph is not $(k,\ell)$-sparse when applicable.
$(k,\ell)$-sparse graphspebble game algorithmsrigidity theorybounded-indegree orientationsrooted arc-connectivityaugmenting pathscentroid decompositioncombinatorial optimizationgraph recognition algorithms
Authors
Bence Deák, Péter Madarasi
Abstract
The family of $(k,\ell)$-sparse graphs, introduced by Lorea, plays a central role in combinatorial optimization and has a wide range of applications, particularly in rigidity theory. A key algorithmic problem is to decide whether a given graph is $(k,\ell)$-sparse and, if not, to produce a vertex set certifying the failure of sparsity. While pebble game algorithms have long yielded $O(n^2)$-time recognition throughout the classical range $0 \leq \ell < 2k$, and $O(n^3)$-time algorithms in the extended range $2k \leq \ell < 3k$, substantially faster bounds were previously known only in a few special cases. We present new recognition algorithms for the parameter ranges $0 \le \ell \le k$, $k < \ell < 2k$, and $2k \leq \ell < 3k$. Our approach combines bounded-indegree orientations, reductions to rooted arc-connectivity, augmenting-path techniques, and a divide-and-conquer method based on centroid decomposition. This yields the first subquadratic, and in fact near-linear-time, recognition algorithms throughout the classical range when instantiated with the fastest currently available subroutines. Under purely combinatorial implementations, the running times become $O(n\sqrt n)$ for $0 \leq \ell \leq k$ and $O(n\sqrt{n\log n})$ for $k< \ell <2k$. For $2k \leq \ell < 3k$, we obtain an $O(n^2)$-time algorithm when $\ell \leq 2k+1$ and an $O(n^2\log n)$-time algorithm otherwise. In each case, the algorithm can also return an explicit violating set certifying that the input graph is not $(k,\ell)$-sparse.