---
title: Single-Source Mincuts Problem
url: https://www.emergentmind.com/topics/single-source-mincuts-problem
type: topic
---

# Single-Source Mincuts Problem

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\) [2507.20354]. 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\)-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 \(G=(V,E,w)\) and a designated source terminal \(s\), the central object is
\[
\lambda_G(s,t)=\min \{\delta_G(S): s\in S,\ t\notin S\},
\qquad
\delta_G(S)=w(\partial_G S).
\]
The single-source mincuts problem asks for these values for all \(t\neq s\) [2507.20354]. In the same paper, for two sets \(A,B\subseteq V\), \(\lambda_G(A,B)\) denotes the minimum cut value among all \((A,B)\)-cuts, and the minimal \((v,r)\)-mincut \(M_{G,v,r}\) is unique.

A rooted formulation also appears in directed graphs. There, an \(s\)-mincut is a minimum-weight cut among all cuts with \(s\in S\), and the global directed mincut can be recovered by solving rooted mincuts in the graph and its reverse [2104.07898]. In fixed-pair directed weighted graphs, an \((s,t)\)-cut is a set \(C\subseteq V\) with \(s\in C\) and \(t\in \overline C\), its capacity is
\[
c(C)=\sum_{e\text{ leaves }C} w(e),
\]
and an \((s,t)\)-mincut is an \((s,t)\)-cut of minimum capacity [2310.12096].

This suggests three recurrent problem types. The first is the exact \(s\)-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 \(u\) have their \(u,s\)-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 \(s\)-to-all problem is laminarity. The minimal \((v,r)\)-mincut \(M_{G,v,r}\) is unique, and the family \(\{M_{G,v,r}\}_{v\neq r}\) is laminar [2507.20354]. 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\) \(k\)-respects a cut \(A\subseteq V\) if at most \(k\) edges of \(T\) cross the cut, and a collection \(\mathcal T\) is a \(k\)-respecting set of guide trees if for every relevant source-target pair \((s,t)\), some tree in \(\mathcal T\) \(k\)-respects some \((s,t)\)-mincut.

A different but related regularity appears in monotone parametric mincut. In a parametric flow network
\[
G=(V,E,c,[\min,\max],s,t),
\]
the source-sink-monotone restriction requires that \(c(s,v)\) is non-decreasing in \(\lambda\), \(c(v,t)\) is non-increasing in \(\lambda\), and all other capacities are constant. Under this condition, if \(\lambda_1<\lambda_2\), then the sink-minimal minimum cuts satisfy
\[
V_s^1 \subseteq V_s^2
\quad\text{and}\quad
V_t^1 \supseteq V_t^2.
\]
The entire parametric solution can therefore be represented by a breakpoint function \(\beta:V\to\mathbb{R}_{\ge 0}\), with
\[
V_s(\lambda)=\{v\in V\mid \beta(v)\le \lambda\},
\qquad
V_t(\lambda)=\{v\in V\mid \beta(v)>\lambda\},
\]
and there are only \(O(n)\) breakpoints [2410.15920].

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 \(2^n\) \(s\)-\(t\) cuts are unique min cuts for some values of the parameters [2107.09743]. 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 \(s\)-to-all problem

The strongest exact algorithmic result in the supplied literature is a deterministic \(m^{1+o(1)}\)-time algorithm for computing \(\lambda(s,t)\) for all \(t\neq s\) in an undirected weighted graph [2507.20354]. The paper first solves a partial problem: recover the exact values \(\lambda(s,t)\) for those \(t\) with
\[
\lambda(s,t)\le 1.1\,\lambda(U),
\qquad
\lambda(U)=\min_{x,y\in U}\lambda(x,y).
\]
The restriction is then removed by iteratively peeling off all vertices whose \(s\)-cut value lies within a \(1.1\) factor of the current minimum. Since \(\lambda(U)\) is exactly the smallest value among the \(\lambda(s,t)\) values for \(t\in U\setminus\{s\}\), each round fixes a set of values permanently and increases the minimum by at least a factor \(1.1\). Repeating this \(\lceil \log_{1.1}(nW)\rceil\) times yields the full single-source solution.

The core combinatorial tool is a deterministic construction of a \(16\)-respecting set of guide trees \(\mathcal T\) with \(|\mathcal T|=n^{o(1)}\). Given one guide tree \(T\) and a fixed constant \(k\ge 2\), the algorithm computes in deterministic \(m^{1+o(1)}\) time a function \(\tilde\lambda\) such that \(\tilde\lambda(t)\ge \lambda(s,t)\) for all \(t\), and \(\tilde\lambda(t)=\lambda(s,t)\) whenever \(T\) \(k\)-respects some \((s,t)\)-mincut. Taking the minimum across all guide trees yields the partial single-source solution. The guide-tree construction proceeds through an approximate packing of \(U\)-Steiner subgraphs, a vertex sparsifier \(G'\) on \(U\), a skeleton graph \(H\) with small global connectivity, and Gabow’s tree-packing algorithm on \(H\).

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 \(U_1,\dots,U_h\), one can compute disjoint cuts \(S_i\) such that each \(S_i\) is the vertex-minimal \((U_i,\bigcup_{j\ne i}U_j)\)-mincut, in deterministic \(m^{1+o(1)}\) time [2507.20354]. A related batching principle appears in deterministic minimum Steiner cut: for a set of terminals \(R\), isolating cuts for all \(v\in R\) can be found using only \(O(\log |R|)\) maximum flow calls, whereas the naive method uses \(|R|\) calls [2111.02008]. 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 \(\lambda\). The objective is no longer to find one mincut, but to compute a set of cuts containing a minimum \((s,t)\)-cut for every parameter value in \([\min,\max]\), or equivalently the breakpoint function in the monotone case [2410.15920]. 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 \(\lambda_i\), the sink component \(V_t\) of the current sink-minimal min cut, a shortest-path tree \(T\) rooted at \(t\) 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:
\[
\lambda_{i+1}=\min_{e\in T} root(e).
\]
The residual bookkeeping is expressed by
\[
sat[\lambda] = \{e\in T \mid c_R[\lambda](e)=0\}
= \{e\in T \mid root(e)=\lambda\}.
\]
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 \(t\) through residual edges.

The correctness proof is organized by inductive invariants, including that the stored breakpoint function is correct for all parameters up to \(\lambda_i\), and that the stored flow \(f^{(i)}[\lambda_i]\) is a maximum flow in the current contracted graph [2410.15920]. The runtime guarantee is
\[
\mathcal O(n^2m),
\]
with initialization in \(\mathcal O(n^2m)\), total tree repair time \(\mathcal O(nm)\), \(\mathcal O(nm)\) main-loop iterations, and \(\mathcal O(n)\) per-iteration overhead. Empirically, PBFS outperforms the previous state of the art on most benchmark instances, usually by a factor of \(2\)–\(3\), and on large polygon aggregation instances with millions of vertices it computes all breakpoints in seconds [2410.15920].

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\subseteq N\) is uniquely optimal somewhere in the parameter plane, giving \(2^n\) distinct min cuts [2107.09743]. 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 \(G=(V,E)\) with source \(s\) so that, after a single edge insertion or failure, it can report the vertices \(u\) whose \(u,s\)-mincut value changes [2607.00894]. For insertions, the \(u,s\)-mincut value changes iff the inserted edge contributes to both
\[
Near(u,s)
\quad\text{and}\quad
Far(u,s),
\]
where \(Near(u,s)\) is the intersection of all \(u,s\)-mincuts and \(Far(u,s)\) is their union. For failures, the value decreases iff the failed edge contributes to some \(u,s\)-mincut, which is structurally harder because the full family of mincuts may be exponentially large.

The main oracle results are an optimal \(O(n)\)-space oracle for edge failures with \(O(n)\) query time, and \(O(n^{1.5})\)-space oracles with near-optimal query times: \(O(\log n)\) one-vertex queries for failures, \(O(1)\) one-vertex queries for insertions, and amortized \(O(\log^3 n)\) time per reported vertex for failures [2607.00894]. The paper also gives an all-pairs structure of \(O(n^{2.5})\) space for reporting all pairs whose mincut decreases upon failure of an edge in amortized \(O(\log^3 n)\) time per reported pair.

The technical core is a bridge between two compact representations. The first is the farthest mincut DAG \(D\), where
\[
Far(u,s) = (\text{descendants of the node containing }u),
\]
and each node has at most two parents. The second is the Connectivity Carcass for Steiner mincuts. The key lemma states that if a \(u,s\)-mincut \(U\) splits a DAG node \(\mu\), then \(U\cap(\mu)\) is a \(\mu\)-mincut and its partition of \(\mu\) is valid in the carcass sense [2607.00894]. 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\) and sink \(t\), an edge is vital if its removal reduces the capacity of \((s,t)\)-mincut. In that setting, there is an algorithm using \(O(n)\) maxflow computations to compute all vital edges and the most vital edge, an \(O(n)\)-space sensitivity oracle that reports the \((s,t)\)-mincut capacity in \(O(1)\) time after failure or insertion of an edge, and an \(O(n^2)\)-space oracle that reports an actual \((s,t)\)-mincut in \(O(n)\) time [2310.12096]. This is not the full \(s\)-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,t)\)-mincut and global mincut: if \(S=\{s,t\}\), Steiner mincut is ordinary \((s,t)\)-mincut, and if \(S=V\), it is global mincut [2409.17715]. In weighted undirected graphs, there is an \(O(n)\)-space sensitivity oracle that reports the capacity of Steiner mincut in \(O(1)\) time after a single edge-weight decrease, and an \(O(n(n-|S|+1))\)-space oracle that reports an actual Steiner mincut in \(O(n)\) time. For \(|S|=n-k\) with constant \(k\ge 0\), the space becomes \(O(n)\), yielding the first \(O(n)\)-space sensitivity oracle for global mincut [2409.17715]. 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 [1911.01651]. In directed graphs, a randomized algorithm finds a mincut using \(\tilde O(\sqrt n)\) maxflow calls by reducing the problem to rooted \(s\)-mincut subproblems, including a subroutine that, given an \(s\)-rooted arborescence crossed once by the true mincut, finds the global mincut using only \(O(\log n)\) maxflow computations [2104.07898].

The boundary of tractability also changes sharply under additional constraints. In the budget-constrained min \(s\)-\(t\) cut problem, one minimizes
\[
\sum_{(i,j)\in E} w_{ij}x_{ij}
\]
subject to the usual cut-validity constraints and the budget constraint
\[
\sum_{(i,j)\in E} c_{ij}x_{ij}\le T.
\]
This problem is NP-complete, and budget-constrained min-cut is NP-complete as well [2308.07063]. 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 \(X\) is a d-MC iff
\[
W(X)=d
\]
and, for every arc \(e_i\in U(X)=\{e_i\mid X(e_i)<W(e_i)\}\),
\[
W\!\left(X+0(e_i)\right)>d.
\]
A correction paper shows that Yeh’s Lemma 3 and Theorem 5 require the missing hypothesis \(W(C)=d\), and that the claimed complexity \(O(mnpo)\) must be replaced by
\[
O\big((m^2+n^2/m)\,po\big)
\]
[1401.0386]. These variants are source-sink mincut problems in broader senses, but they are not the same as the exact \(s\)-to-all single-source mincuts problem.

Overall, the literature defines the single-source mincuts problem most sharply as exact computation of \(\lambda(s,t)\) for all \(t\neq s\), now known to admit a deterministic \(m^{1+o(1)}\)-time algorithm in undirected weighted graphs [2507.20354]. 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.

Source: https://www.emergentmind.com/topics/single-source-mincuts-problem