Single-Source Mincuts Problem

• Single-Source Mincuts Problem is defined as computing the minimum s-to-t cut value for every vertex t in an undirected weighted graph.
• The approach employs structural laminarity and guide trees to design deterministic, almost-linear time algorithms that efficiently compute these cuts.
• Extensions include parametric mincuts and sensitivity oracles that address edge updates, broadening the problem's applicability in network analysis.

The single-source mincuts problem is the task of fixing a source vertex $s$ and computing the minimum $s$-to-$t$ cut value for every other vertex $t$. In the formulation used for undirected weighted graphs, the goal is to output

$\{\lambda_G(s,t): t\in V\setminus\{s\}\},$

where $\lambda_G(s,t)$ is the minimum value of $\delta_G(S)=w(\partial_G S)$ over all cuts $S\subseteq V$ with $s\in S$ and $t\notin S$ (Abboud et al., 27 Jul 2025). The same source-based viewpoint also appears in closely related settings: rooted mincuts in directed graphs, source-sink monotone parametric mincut, and single-edge sensitivity oracles that report which source-to-vertex mincut values change after an update. This suggests a useful distinction between the core $s$0-to-all value problem and a broader family of source-based mincut problems.

1. Formal problem statement and basic variants

For an undirected weighted graph $s$1 and a designated source terminal $s$2, the central object is

$s$3

The single-source mincuts problem asks for these values for all $s$4 (Abboud et al., 27 Jul 2025). In the same paper, for two sets $s$5, $s$6 denotes the minimum cut value among all $s$7-cuts, and the minimal $s$8-mincut $s$9 is unique.

A rooted formulation also appears in directed graphs. There, an $t$0-mincut is a minimum-weight cut among all cuts with $t$1, and the global directed mincut can be recovered by solving rooted mincuts in the graph and its reverse (Cen et al., 2021). In fixed-pair directed weighted graphs, an $t$2-cut is a set $t$3 with $t$4 and $t$5, its capacity is

$t$6

and an $t$7-mincut is an $t$8-cut of minimum capacity (Baswana et al., 2023).

This suggests three recurrent problem types. The first is the exact $t$9-to-all value problem. The second is the fixed-source, fixed-sink problem under parameter variation, where one seeks all distinct optimal cuts as a scalar parameter changes. The third is the update-sensitive problem, where preprocessing supports fast reporting of which vertices $t$0 have their $t$1-mincut value changed after an edge insertion or failure.

2. Structural regularity: laminarity, guide trees, and nested cuts

A central structural fact for the exact $t$2-to-all problem is laminarity. The minimal $t$3-mincut $t$4 is unique, and the family $t$5 is laminar (Abboud et al., 27 Jul 2025). That laminarity is used both in the deterministic single-source algorithm and in the decomposition framework for deterministic Gomory-Hu tree construction. The same paper also introduces guide trees: a tree $t$6 $t$7-respects a cut $t$8 if at most $t$9 edges of $\{\lambda_G(s,t): t\in V\setminus\{s\}\},$0 cross the cut, and a collection $\{\lambda_G(s,t): t\in V\setminus\{s\}\},$1 is a $\{\lambda_G(s,t): t\in V\setminus\{s\}\},$2-respecting set of guide trees if for every relevant source-target pair $\{\lambda_G(s,t): t\in V\setminus\{s\}\},$3, some tree in $\{\lambda_G(s,t): t\in V\setminus\{s\}\},$4 $\{\lambda_G(s,t): t\in V\setminus\{s\}\},$5-respects some $\{\lambda_G(s,t): t\in V\setminus\{s\}\},$6-mincut.

A different but related regularity appears in monotone parametric mincut. In a parametric flow network

$\{\lambda_G(s,t): t\in V\setminus\{s\}\},$7

the source-sink-monotone restriction requires that $\{\lambda_G(s,t): t\in V\setminus\{s\}\},$8 is non-decreasing in $\{\lambda_G(s,t): t\in V\setminus\{s\}\},$9, $\lambda_G(s,t)$0 is non-increasing in $\lambda_G(s,t)$1, and all other capacities are constant. Under this condition, if $\lambda_G(s,t)$2, then the sink-minimal minimum cuts satisfy

$\lambda_G(s,t)$3

The entire parametric solution can therefore be represented by a breakpoint function $\lambda_G(s,t)$4, with

$\lambda_G(s,t)$5

and there are only $\lambda_G(s,t)$6 breakpoints (Beines et al., 2024).

That regularity is specific to the one-parameter monotone setting. In the two-parameter source-sink monotone framework, the coordinatewise order still implies nestedness for comparable parameter points, but the number of distinct min cuts can nevertheless be exponential: there exist instances with two parameters where all $\lambda_G(s,t)$7 $\lambda_G(s,t)$8-$\lambda_G(s,t)$9 cuts are unique min cuts for some values of the parameters (Allman et al., 2021). This directly separates “nestedness” from “small state space”: along a total order, nesting yields only linearly many changes, but in a partial order the global family can still explode.

3. Deterministic almost-linear algorithms for the core $\delta_G(S)=w(\partial_G S)$0-to-all problem

The strongest exact algorithmic result in the supplied literature is a deterministic $\delta_G(S)=w(\partial_G S)$1-time algorithm for computing $\delta_G(S)=w(\partial_G S)$2 for all $\delta_G(S)=w(\partial_G S)$3 in an undirected weighted graph (Abboud et al., 27 Jul 2025). The paper first solves a partial problem: recover the exact values $\delta_G(S)=w(\partial_G S)$4 for those $\delta_G(S)=w(\partial_G S)$5 with

$\delta_G(S)=w(\partial_G S)$6

The restriction is then removed by iteratively peeling off all vertices whose $\delta_G(S)=w(\partial_G S)$7-cut value lies within a $\delta_G(S)=w(\partial_G S)$8 factor of the current minimum. Since $\delta_G(S)=w(\partial_G S)$9 is exactly the smallest value among the $S\subseteq V$0 values for $S\subseteq V$1, each round fixes a set of values permanently and increases the minimum by at least a factor $S\subseteq V$2. Repeating this $S\subseteq V$3 times yields the full single-source solution.

The core combinatorial tool is a deterministic construction of a $S\subseteq V$4-respecting set of guide trees $S\subseteq V$5 with $S\subseteq V$6. Given one guide tree $S\subseteq V$7 and a fixed constant $S\subseteq V$8, the algorithm computes in deterministic $S\subseteq V$9 time a function $s\in S$0 such that $s\in S$1 for all $s\in S$2, and $s\in S$3 whenever $s\in S$4 $s\in S$5-respects some $s\in S$6-mincut. Taking the minimum across all guide trees yields the partial single-source solution. The guide-tree construction proceeds through an approximate packing of $s\in S$7-Steiner subgraphs, a vertex sparsifier $s\in S$8 on $s\in S$9, a skeleton graph $t\notin S$0 with small global connectivity, and Gabow’s tree-packing algorithm on $t\notin S$1.

The recursive procedure on a guide tree uses two derandomization tools: the Isolating Cuts Lemma and a hit-and-miss family. The Isolating Cuts Lemma states that given disjoint terminal sets $t\notin S$2, one can compute disjoint cuts $t\notin S$3 such that each $t\notin S$4 is the vertex-minimal $t\notin S$5-mincut, in deterministic $t\notin S$6 time (Abboud et al., 27 Jul 2025). A related batching principle appears in deterministic minimum Steiner cut: for a set of terminals $t\notin S$7, isolating cuts for all $t\notin S$8 can be found using only $t\notin S$9 maximum flow calls, whereas the naive method uses $s$00 calls (Li et al., 2021). This suggests that the modern single-source algorithms are built around terminal batching rather than one max-flow computation per destination.

4. Parametric single-source-style mincuts and breakpoint enumeration

In monotone parametric minimum cut, the source and sink remain fixed but capacities vary with a scalar parameter $s$01. The objective is no longer to find one mincut, but to compute a set of cuts containing a minimum $s$02-cut for every parameter value in $s$03, or equivalently the breakpoint function in the monotone case (Beines et al., 2024). This is a parametric extension of ordinary single-source min-cut/max-flow in which the relevant output is the sequence of distinct optimal source sides.

The algorithm introduced in this setting is parametric breadth-first search (PBFS). PBFS is inspired by incremental breadth-first search for static max-flow and processes breakpoints in ascending order. It maintains a current maximum flow for the current parameter value $s$04, the sink component $s$05 of the current sink-minimal min cut, a shortest-path tree $s$06 rooted at $s$07 inside the residual graph of the current contracted graph, and flow functions on edges. The next breakpoint is determined by the first tree edge that saturates: $s$08 The residual bookkeeping is expressed by

$s$09

When a tree edge saturates, PBFS removes it, repairs the forest by an IBFS-style vertex adoption procedure, and assigns the current breakpoint to any vertex that can no longer reach $s$10 through residual edges.

The correctness proof is organized by inductive invariants, including that the stored breakpoint function is correct for all parameters up to $s$11, and that the stored flow $s$12 is a maximum flow in the current contracted graph (Beines et al., 2024). The runtime guarantee is

$s$13

with initialization in $s$14, total tree repair time $s$15, $s$16 main-loop iterations, and $s$17 per-iteration overhead. Empirically, PBFS outperforms the previous state of the art on most benchmark instances, usually by a factor of $s$18–$s$19, and on large polygon aggregation instances with millions of vertices it computes all breakpoints in seconds (Beines et al., 2024).

The one-parameter setting is exceptional. In the two-parameter source-sink monotone model, the family remains nested only along comparable points, and there are constructions in which every subset $s$20 is uniquely optimal somewhere in the parameter plane, giving $s$21 distinct min cuts (Allman et al., 2021). Explicit cell enumeration is therefore ruled out in the worst case for multi-parameter source-sink monotone mincut.

5. Sensitivity oracles and update-aware source-based mincuts

A single-source mincut sensitivity oracle preprocesses an undirected multigraph $s$22 with source $s$23 so that, after a single edge insertion or failure, it can report the vertices $s$24 whose $s$25-mincut value changes (Bhanja et al., 1 Jul 2026). For insertions, the $s$26-mincut value changes iff the inserted edge contributes to both

$s$27

where $s$28 is the intersection of all $s$29-mincuts and $s$30 is their union. For failures, the value decreases iff the failed edge contributes to some $s$31-mincut, which is structurally harder because the full family of mincuts may be exponentially large.

The main oracle results are an optimal $s$32-space oracle for edge failures with $s$33 query time, and $s$34-space oracles with near-optimal query times: $s$35 one-vertex queries for failures, $s$36 one-vertex queries for insertions, and amortized $s$37 time per reported vertex for failures (Bhanja et al., 1 Jul 2026). The paper also gives an all-pairs structure of $s$38 space for reporting all pairs whose mincut decreases upon failure of an edge in amortized $s$39 time per reported pair.

The technical core is a bridge between two compact representations. The first is the farthest mincut DAG $s$40, where

$s$41

and each node has at most two parents. The second is the Connectivity Carcass for Steiner mincuts. The key lemma states that if a $s$42-mincut $s$43 splits a DAG node $s$44, then $s$45 is a $s$46-mincut and its partition of $s$47 is valid in the carcass sense (Bhanja et al., 1 Jul 2026). This allows carcass machinery to be used locally inside DAG nodes.

A fixed-pair specialization appears in directed weighted graphs. For a designated source $s$48 and sink $s$49, an edge is vital if its removal reduces the capacity of $s$50-mincut. In that setting, there is an algorithm using $s$51 maxflow computations to compute all vital edges and the most vital edge, an $s$52-space sensitivity oracle that reports the $s$53-mincut capacity in $s$54 time after failure or insertion of an edge, and an $s$55-space oracle that reports an actual $s$56-mincut in $s$57 time (Baswana et al., 2023). This is not the full $s$58-to-all problem, but it gives a strong source-based sensitivity theory for the fixed terminal pair case.

6. Interfaces with Steiner, global, and constrained mincut

Single-source mincuts sit inside a wider mincut landscape. Steiner mincut generalizes both $s$59-mincut and global mincut: if $s$60, Steiner mincut is ordinary $s$61-mincut, and if $s$62, it is global mincut (Bhanja, 2024). In weighted undirected graphs, there is an $s$63-space sensitivity oracle that reports the capacity of Steiner mincut in $s$64 time after a single edge-weight decrease, and an $s$65-space oracle that reports an actual Steiner mincut in $s$66 time. For $s$67 with constant $s$68, the space becomes $s$69, yielding the first $s$70-space sensitivity oracle for global mincut (Bhanja, 2024). This suggests that source-based and terminal-based mincut data structures interpolate smoothly as the terminal set grows.

Other connections are algorithmic rather than definitional. Exact global mincut in weighted graphs can be reduced to the 2-respecting min-cut subproblem via Karger’s tree packing, and improved algorithms for that subproblem yield better exact min-cut bounds in sequential, cut-query, and dynamic streaming models (Mukhopadhyay et al., 2019). In directed graphs, a randomized algorithm finds a mincut using $s$71 maxflow calls by reducing the problem to rooted $s$72-mincut subproblems, including a subroutine that, given an $s$73-rooted arborescence crossed once by the true mincut, finds the global mincut using only $s$74 maxflow computations (Cen et al., 2021).

The boundary of tractability also changes sharply under additional constraints. In the budget-constrained min $s$75-$s$76 cut problem, one minimizes

$s$77

subject to the usual cut-validity constraints and the budget constraint

$s$78

This problem is NP-complete, and budget-constrained min-cut is NP-complete as well (Puerto et al., 2023). The paper gives an exact branch-and-bound method and a non-exact Lagrangean relaxation for the min-cut case. In stochastic-flow reliability, the d-MinCut problem is again different: a system-state vector $s$79 is a d-MC iff

$s$80

and, for every arc $s$81,

$s$82

A correction paper shows that Yeh’s Lemma 3 and Theorem 5 require the missing hypothesis $s$83, and that the claimed complexity $s$84 must be replaced by

$s$85

(Forghani-elahabad et al., 2014). These variants are source-sink mincut problems in broader senses, but they are not the same as the exact $s$86-to-all single-source mincuts problem.

Overall, the literature defines the single-source mincuts problem most sharply as exact computation of $s$87 for all $s$88, now known to admit a deterministic $s$89-time algorithm in undirected weighted graphs (Abboud et al., 27 Jul 2025). Around that core problem lies a substantial source-based ecosystem: parametric breakpoint enumeration under source-sink monotonicity, update-sensitive oracles for insertions and failures, rooted reductions for global mincut, and constrained or reliability-oriented variants in which the source-based cut viewpoint is preserved but the computational behavior changes substantially.