Exact Fully-Dynamic Min-Cut Algorithm

• Exact fully-dynamic min-cut algorithms are techniques that update and report exact min-cut values in evolving undirected graphs using sparsification and advanced data structures.
• They leverage friendly-cut sparsifiers and star transforms to bypass max-flow bottlenecks, achieving O(1) query time and subquadratic worst-case update times.
• These methods ensure robustness under adversarial edge updates and extend applications to dynamic network resilience and planar graph optimizations.

An exact fully-dynamic minimum cut algorithm processes an evolving undirected graph under online edge insertions and deletions, maintaining the ability to report, for any vertex pair, the exact value of a minimum $s$–$t$ cut. These algorithms are central to dynamic graph connectivity, All-Pairs Minimum Cut (APMC), and network resilience, especially as they generalize static cut computation and support worst-case adversarial update sequences. Recent breakthroughs have addressed key obstacles: subquadratic update time models for general graphs, deterministic subpolynomial-time algorithms for superpolylogarithmic cut-sizes, and highly efficient data structures for non-trivial minimum-cuts.

1. Problem Framework and Objectives

The classic model assumes a simple, undirected, unweighted graph $G = (V, E)$ on fixed $n = |V|$ vertices, subject to a sequence of operations:

• $\mathsf{Insert}(u,v)$: Insert edge $(u,v)$.
• $\mathsf{Delete}(u,v)$: Delete edge $(u,v)$.
• $\mathsf{Query}(s,t)$: Return $\lambda_G(s,t)$, the exact value of the minimum $s$–$t$ cut.

The objective is to maintain all-pairs min-cut values (i.e., a Gomory–Hu forest or tree), supporting worst-case or amortized bounds on update/query time, space, and, in some approaches, explicit cut/cactus representations. At the core is the ability to support adversarially interleaved updates and queries in the worst-case, often with a focus on erasing the need for explicit max-flow computations in the update loop (Kenneth-Mordoch et al., 13 Nov 2025), as these remain bottlenecks in classical fully-dynamic frameworks.

2. Sparsification and Gomory–Hu Structures

The recent state-of-the-art leverages sparsification: replacing the large, dense input graph by a much smaller graph (a “sparsifier”) that exactly preserves all minimum $s$–$t$ cuts, thus enabling faster computation of Gomory–Hu trees.

Key methodology (Kenneth-Mordoch et al., 13 Nov 2025):

• Friendly–cut sparsifiers: A recursively constructed contraction $H_{\mathrm{fr}}$ of $G$ preserving all “$\alpha$-friendly” cuts up to size $w$, for fixed parameters (e.g., $(1/6, 2n)$). These use expander decomposition with careful contraction and degree shaving, admitting robust preservation through $\tilde O(\sqrt n)$ updates and $\tilde O(n^{3/2})$ edge size.
• Star Transform: Converts $H_{\mathrm{fr}}$ into an APMC sparsifier $H_{\mathrm{ap}}$ by splitting contracted supervertices and inserting weighted proxy edges, achieving $\lambda_{H_{\mathrm{ap}}}(s,t) = \lambda_G(s,t)$ for all pairs. This bypasses direct dependence on max-flow and enables static Gomory–Hu tree algorithms to be used on the sparsifier.
• Dynamic maintenance: By running two parallel sparsifiers (each robust for $\sqrt n$ updates) and shifting between them at epoch boundaries, plus replaying a buffer of recent updates, the framework ensures that a fresh sparsifier and its tree can be rebuilt in $n^{3/2+o(1)}$ time per update in the worst-case.

This approach admits $O(1)$ query time for $(s,t)$ min-cut and $\tilde O(n^{3/2})$ worst-case update time for the exact all-pairs problem in unweighted graphs (Kenneth-Mordoch et al., 13 Nov 2025).

3. Algorithmic and Structural Components

A selection of technical ingredients repeatedly occurs (summarized in this table):

Component Type	Function in Dynamic Min-Cut Algorithms	Key Paper
Expander Decomposition	Enables compressive structure and friendly sparsifiers	(Kenneth-Mordoch et al., 13 Nov 2025)
Tree Packing	Forms basis for 1-respecting cut identification	(Vos et al., 15 May 2024)
Dynamic Forest DS	Underlies contraction/partition operations, NMC	(Henzinger et al., 5 Sep 2025)
LocalKCut Enumeration	Detects boundary-sparse and cluster-local min cuts	(El-Hayek et al., 15 Dec 2025)
Cactus Representation	Compactly encodes all global minimum cuts	(Henzinger et al., 5 Sep 2025)

• Expander-decomposition techniques recursively split the graph into vertex-disjoint expanders, contracting tight components as supervertices to reduce the problem size—this is central both for friendly-cut sparsifier and for achieving robust sublinear-sized graphs (Kenneth-Mordoch et al., 13 Nov 2025).
• Star transform preserves all min-cuts by attaching proxy vertices to each supervertex, ensuring that “unfriendly” min-cuts (those with low-degree endpoints) are exactly reconstructed in the transformed graph.
• Dynamic Forest data structures (DSF, DCS) are critical to non-trivial min-cut sparsifiers, efficiently supporting edge insert/delete and contractions necessary for constructing the sparsified representation on-the-fly (Henzinger et al., 5 Sep 2025).
• Tree-packing and greedy forests underlie both classical and modern frameworks for identifying 1-respecting minimum cuts and building (1+$\varepsilon$)-arboricity approximations efficiently under dynamics (Vos et al., 15 May 2024).
• Cactus representations are efficiently constructed in $O(n)$ time from the sparsified or contracted graphs and support reporting all minimum cuts, not only their values (Henzinger et al., 5 Sep 2025).

4. Complexity Bounds and Model Variants

State-of-the-art exact fully-dynamic min-cut algorithms achieve the following complexity bounds (for unweighted, general graphs):

Algorithmic Paradigm	Supported Cut Size	Update Time	Query Time	Reference
Friendly-cut/Star-SP	All-pairs	$n^{3/2+o(1)}$ w.c.	$O(1)$	(Kenneth-Mordoch et al., 13 Nov 2025)
NMC sparsifier + cactus	All non-trivial	$\widehat O(1)$ w.c.	$\widehat O(n)$	(Henzinger et al., 5 Sep 2025)
Dynamic tree-packing	$\lambda$-bounded	$\tilde O(\lambda^{5.5}\sqrt n)$	$\tilde O(\lambda \log m)$	(Vos et al., 15 May 2024)
Deterministic local min-cut	$2^{\Theta(\log^{3/4-c} n)}$	$n^{o(1)}$ amort.	$n^{o(1)}$	(El-Hayek et al., 15 Dec 2025)
Multi-level expander/sparsifier	$(\log n)^{o(1)}$	$n^{o(1)}$ w.c.	$O(\log n)$	(Jin et al., 18 Jan 2024)

w.c. = worst-case, amort. = amortized

Notable points:

• Previous polylogarithmic or $\tilde O(\sqrt{n})$-time bounds were restricted to global cuts of small size or specific graph classes.
• For high-minimum-degree graphs, non-trivial min-cut sparsifiers admit fully dynamic cactus reporting of all min-cuts in linear time upon query, while still maintaining $\widehat O(1)$ (polylogarithmic) update time (Henzinger et al., 5 Sep 2025).
• The combination of dynamic sparsifiers and static (cactus or Gomory–Hu) computation forms a performant hybrid: the data structure is compact and fast to maintain, while explicit cut extraction incurs at most $O(n)$ time per query.

5. Exactness, Robustness, and Lower Bounds

A principal challenge in designing fully-dynamic exact algorithms is robustly maintaining correctness against arbitrary update sequences. Structural guarantees stem from leveraging:

• Expander properties: High expansion enforces that all “friendly” small cuts must survive contraction, and the star transform restores any “unfriendly” min-cuts lost by contraction (Kenneth-Mordoch et al., 13 Nov 2025).
• Randomized contraction and sampling: NMC sparsifiers built by random 2-out contraction (Ghaffari–Nowicki–Thorup) achieve $O(n/\delta)$ vertex and $O(n)$ edge size, with high-probability exactness against adaptive adversaries (Henzinger et al., 5 Sep 2025).
• Tree packing theory: Existence of a tree with a 1-respecting cut for some global min-cut (or trivial cut in the contracted graph) is guaranteed by packing $O(\lambda^3 \log m)$ trees (Vos et al., 15 May 2024).

The lower bounds remain governed by either max-flow complexity in the worst-case or limitations of the cut structure. For instance, general fully-dynamic min-cut in nonplanar graphs cannot, in the worst case, be solved in $o(\sqrt m)$ per update barring improved max-flow algorithms, though dynamic queries on planar graphs now admit $O(n^{2/3}\log^3 n)$ amortized bounds (Italiano et al., 2010).

6. Related Models: Planar and Weighted Extensions

For specific graph classes, especially planar graphs, recent algorithms achieve further improvements by exploiting planarity:

• Italiano and Sankowski developed the first fully-dynamic algorithm supporting min-cut and max-flow queries between any pair in $O(n^{2/3}\log^3 n)$ amortized time, using r-partitions of dual graphs, dense-distance graphs, and hybrid FR–Dijkstra shortest-path algorithms (Italiano et al., 2010). These approaches critically depend on planar separator properties and embedding, not applicable to general graphs.
• Incorporating weights introduces extra complications. For weighted graphs, practical exact dynamic min-cut is attained through cactus representation and early-terminated push–relabel flows, with experiments showing orders-of-magnitude speedups over static recomputation in very large networks (Henzinger et al., 2021).

7. Directions, Limitations, and Open Problems

Major breakthroughs have occurred in the last few years, particularly regarding sparsification techniques and deterministic subpolynomial time. Noteworthy limitations and open challenges include:

• Handling all cut-sizes, especially for minimum cut values larger than superpolylogarithmic, remains open for deterministic $n^{o(1)}$-time fully-dynamic algorithms (El-Hayek et al., 15 Dec 2025).
• Extending these methods to efficiently support weighted, directed, or partially dynamic variants, as well as further reductions in the $n^{3/2+o(1)}$ barrier, form active research areas.
• There is still a sizable gap between amortized and worst-case update time in some practical settings and between theoretical upper and information-theoretic lower bounds.

The field continues to evolve rapidly, with methods such as robust sparsifiers and dynamic tree packings redefining what is tractable for fully-dynamic network cut problems in both theory and practice (Kenneth-Mordoch et al., 13 Nov 2025, Henzinger et al., 5 Sep 2025, Vos et al., 15 May 2024, El-Hayek et al., 15 Dec 2025).