Fully dynamic biconnectivity in $\tilde{\mathcal{O}}(\log^2 n)$ time

TL;DR

The paper tackles the problem of fully dynamic biconnectivity, presenting a deterministic structure that maintains cut-vertices and supports inserts/deletes with amortized $\tilde{O}(\log^2 n)$ update time and worst-case $O(\log n \log^2 \log n)$ queries. The core approach chains a sequence of reductions: dynamic biconnectivity to a tree-cover level data structure, to neighborhood data structures, and finally to biased disjoint sets with VIP neighbor techniques and transient exposes. The main contributions include a formally defined transient expose operation, a neighborhood-structure framework with counting/marking extensions, a novel biased disjoint-set data structure, and a refined top-tree–based cover-level implementation that achieves near $\tilde{O}(\log^2 n)$ performance. These components yield a scalable, deterministic solution that matches the best known deterministic dynamic connectivity bounds up to polylogarithmic factors and illuminate techniques for reducing complex graph problems to structured data-structure subproblems. The work advances the state of dynamic graph algorithms by introducing new concepts ( transient expose, VIP neighbors) and deep data-structural reductions that may inspire further improvements in related connectivity problems and combinatorial structures.

Abstract

We present a deterministic fully-dynamic data structure for maintaining information about the cut-vertices in a graph; i.e. the vertices whose removal would disconnect the graph. Our data structure supports insertion and deletion of edges, as well as queries to whether a pair of connected vertices are either biconnected, or can be separated by a cutvertex, and in the latter case we support access to separating cutvertices. All update operations are supported in amortized $O(\log^2 n \log^2 \log n)$ time, and queries take worst-case $O(\log n \log^2 \log n)$ time. Note that these time bounds match the current best for deterministic dynamic connectivity up to $\log \log n$ factors. We obtain our improved running time by a series of reductions from the original problem into well-defined data structure problems. While we do apply the well-known techniques for improving running time of two-edge connectivity [STOC'00, SODA'18], these techniques alone do not lead to an update time of $\tilde{O}(\log^3 n)$, let alone the $\tilde{O}(\log^2 n)$ we give as a final result. Our contributions include a formally defined transient expose operation, which can be thought of as a cheaper read-only expose operation on a top tree. For each vertex in the graph, we maintain a data structure over its neighbors, and in this data structure we apply biasing (twice) to save two $\tilde{O}(\log n)$ factors. One of these biasing techniques is a new biased disjoint sets data structure, which may be of independent interest. Moreover, in this neighborhood data structure, we facilitate that the vertex can select two VIP neighbors that get special treatment, corresponding to its potentially two neighbors on an exposed path, improving a $\log n$-time operation down to constant time. It is this combination of VIP neighbors with the transient expose that saves an $\tilde{O}(\log n)$-factor from another bottleneck.

Figures (3)

• Figure 1: Let $xy$ and $yz$ be consecutive along the tree path $v \ldots w$. Then, deleting the non-tree edge $vw$ may cause the biconnected component containing $xy$ and $yz$ (pink) to split up into new biconnected components (purple). Other biconnected components near $y$ are unaffected (green).
• Figure 2: All possible ways in which a cluster $C$ can split into child clusters.
• Figure 3: Time complexity bounds of the combined data structure from \ref{['lem:ds-tree-cover-levels', 'lem:ds-tree-find-size', 'lem:tree-cover-findfirst']}. Here, T denotes the time complexity of the query, excluding calls to transient exposes and calls to the neighborhood data structures performed as subroutines. Next, NC is the total normalized cost of the calls to the neighborhood data structures performed by the query, excluding the calls stemming from a transient expose; and the Subqueries column immediately right of it lists the types queries to these neighborhood data structures performed by the considered operations, and determines whether a transient expose is performed as a subroutine.

Theorems & Definitions (19)

• proof
• proof
• proof
• proof
• proof
• proof
• proof
• proof : Proof of \ref{['lem:transient-expose-lemma']}
• proof : Proof of the claim
• proof