Version 5.0 The LEDA User Manual

12.3 Maximum Flow ( max flow )
Let G = (V, E) be a directed graph, let s and t be distinct vertices in G and let cap :
E −→ IR ≥0 be a non-negative function on the edges of G. For an edge e, we call cap(e)
the capacity of e. An (s, t)-flow or simply flow is a function f : E −→ IR ≥0 satisfying the
capacity constraints and the flow conservation constraints:
(1) 0 ≤ f(e) ≤ cap(e) for every edge e ∈ E
∑
∑
(2)
f(e) = f(e) for every node v ∈ V \{s, t}
e;source(e)=v
e;target(e)=v
The value of the flow is the net flow into t (equivalently, the net flow out of s). The net
flow into t is the flow into t minus the flow out of t. A flow is maximum if its value is at
least as large as the value of any other flow.
All max flow implementations are template functions. The template parameter NT can
be instantiated with any number type. In order to use the template version of the function
the files
#include
#include
must be included.
There are pre-instantiations for the number types int and double.The pre-instantiated
versions have the same function names except for the suffix _T. In order to use them
either
#include
or
#include
has to be included (the latter file includes the former). The connection between template
functions and pre-instantiated functions is discussed in detail in the section “Templates
for Network Algorithms” of the LEDA book.
Special care should be taken when using the template functions with a number type NT
that can incur rounding error, e.g., the type double. The section “Algorithms on Weighted
Graphs and Arithmetic Demand” of the LEDA book contains a general discussion of this
issue. The template functions are only guaranteed to perform correctly if all arithmetic
performed is without rounding error. This is the case if all numerical values in the input
are integers (albeit stored as a number of type NT ) and if none of the intermediate
results exceeds the maximal integer representable by the number type (2 53 − 1 in the
case of doubles). All intermediate results are sums and differences of input values, in
particular, the algorithms do not use divisions and multiplications.