Flüsse und Schnitte in Netzwerken

Flüsse und Schnitte in Netzwerken sind Strukturen der Graphentheorie, die vielfältige Anwendungen finden.

Definitionen, wichtige Begriffe und Eigenschaften

Netzwerk

Ein Netzwerk (engl. network) $N=(G,u,s,t)$ besteht aus einem gerichteten Graphen $G=(V,E)$ mit zwei ausgezeichneten Knoten (engl. vertex/vertices), einer Quelle (engl. source) $s$ und einer Senke (engl. target) $t$ aus $V$, sowie einer Kapazitätsfunktion $u\colon E\rightarrow \mathbb {R} _{+}$, die jeder Kante $e\in E$ eine nichtnegative Kapazität zuweist, $e\mapsto u(e)$. Hat die Kapazitätsfunktion ausschließlich ganzzahlige Werte, so existiert eine maximale Flussfunktion (siehe folgende Definition), die ebenfalls nur ganzzahlige Werte hat.

Fluss

• 

  Beispiel für einen Fluss. Die Belegung steht zusammen mit der Kapazität an den einzelnen Kanten. Der Wert des $s$-$t$-Flusses ist 2.

• 

  Beispiel für ein Residualnetzwerk. Auf dem Pfad $s$, $a$, $b$, $t$ lässt sich der Fluss um den Wert 2 augmentieren.

Ein Fluss ist eine Funktion $f\colon E\rightarrow \mathbb {R} _{+}$, die jeder Kante $e\in E$ im Netzwerk einen nichtnegativen Flusswert $f(e)\in \mathbb {R} _{+}$ zuweist. Dabei muss folgende Bedingung erfüllt sein:

Kapazitätskonformität:

Der Flusswert auf einer Kante ist höchstens so groß wie die Kapazität der Kante, das heißt, es gilt:

$\forall e\in E:f(e)\leq u(e)$.

Ist zusätzlich die folgende Bedingung erfüllt, heißt der Fluss $s$-$t$-Fluss:

Flusserhalt:

Abgesehen von der Quelle s und der Senke t muss in jeden Knoten genau so viel hineinfließen wie herausfließt, das heißt:

$\forall v\in V\setminus \{s,t\}:\sum _{e\in \operatorname {\delta ^{-}} (v)}f(e)=\sum _{e\in \operatorname {\delta ^{+}} (v)}f(e)$

Dabei ist

$\operatorname {\delta ^{-}} (v){\overset {\underset {\mathrm {def} }{}}{=}}\{e=(x,v)\in E\mid x\in V\}$

die Menge der in $v$ hineinführenden und

$\operatorname {\delta ^{+}} (v){\overset {\underset {\mathrm {def} }{}}{=}}\{e=(v,x)\in E\mid x\in V\}$

die Menge der aus $v$ hinausführenden Kanten.

Gilt zudem Flusserhalt auch in $s$ und $t$, hat man eine Strömung oder Zirkulation. Man kann zeigen, dass Inzidenzvektoren einer Zirkulation entsprechen, wenn sie im Zyklenraum $Z(G)$ von $G$ liegen.

Exzess

Der Exzess $\operatorname {ex} (v)$ eines Knotens $v$, oder auch Nettofluss oder Überschuss genannt, ist die Differenz der Summe der Flusswerte der eingehenden Kanten und der Summe der Flusswerte der ausgehenden Kanten.

$\operatorname {ex} (v){\overset {\underset {\mathrm {def} }{}}{=}}\sum _{e\in \operatorname {\delta ^{-}} (v)}f(e)-\sum _{e\in \operatorname {\delta ^{+}} (v)}f(e)$

Beispiel für einen Schnitt. Die Kapazität des Schnittes ist ${\begin{aligned}&\quad \ u((s,b))\\&+u((a,b))\\&+u((a,t))\\&=1+2+1=4\\\end{aligned}}$

Wert

Der Wert eines $s$-$t$-Flusses $f$ ist der Überschuss im Knoten $t$ oder der Betrag des Überschusses im Knoten $s$.

In Formeln:

$|f|=\sum _{e\in \operatorname {\delta ^{+}} (s)}f(e)-\sum _{e\in \operatorname {\delta ^{-}} (s)}f(e)$, wobei $s$ die Quelle des Netzwerkes bezeichnet.

Für alle $s$-$t$-Flüsse ist der Überschuss bis auf $s,t$ für alle Knoten Null. Für alle Zirkulationen ist er auch in $s,t$ Null.

Schnitt

Eine echte Teilmenge $S$ der Knoten in einem Netzwerk, die $s$, aber nicht $t$ enthält, nennt man einen $s$-$t$-Schnitt. Oft wird unter einem Schnitt auch die Menge aller Kanten verstanden, die zwischen den Partitionen $S$ und $V\setminus S$ verlaufen. Die Kapazität eines Schnittes ist die Summe der Kapazitäten der von $S$ nach $V\setminus S$ verlaufenden Kanten.

Schnitte geben eine obere Schranke für den Wert der $s$-$t$-Flüsse. Das Max-Flow-Min-Cut-Theorem besagt, dass auch umgekehrt Flusswerte eine Untere Schranke für Schnittkapazitäten sind. Beide Konzepte entsprechen also einander auf eine natürliche Art und Weise.

Ferner entspricht der Fluss im gesamten Netzwerk dem Fluss durch einen beliebigen Schnitt. Zusammen mit der Kapazität des Schnittes gilt daher $f(S,T)=|f|\leq c(S,T)$. Handelt es sich um einen minimalen Schnitt, entspricht der Fluss der Kapazität des Schnittes.

Residualnetzwerk

Das Residualnetzwerk $N_{f}$, oder auch Restnetzwerk, zum Fluss $f$ mit Residualgraphen $G_{f}$ und Residualkapazitäten $u_{f}$ zeigt die restlichen Kapazitäten des Netzwerks an. Der Residualgraph $G_{f}$ hat dieselbe Knotenmenge wie $G$ und besteht aus den von $f$ nicht ausgelasteten Kanten ergänzt um Rückkanten: Für jede Kante $e=(v,w)\in E$ mit $f(e)>0$ enthält $E_{f}$ eine Rückkante ${\overleftarrow {e}}=(w,v)$. Die Residualkapazitäten $u_{f}(e)$ geben für eine Kante $e\in E$ an, um wie viel der Fluss auf ihr noch erhöht werden kann, und für eine Rückkante ${\overleftarrow {e}}$, um wie viel der Fluss auf der zugehörigen Hinkante verringert werden darf. Also:

$\forall e\in E:u_{f}(e)=u(e)-f(e)$, falls $f(e)<u(e)$

$\forall {\overleftarrow {e}}\in E_{f}\setminus E:u_{f}({\overleftarrow {e}})=f(e)$

Algorithmische Konstruktion eines Residualnetzwerks

Initialisiere $E_{f}=\emptyset$; $u_{f}\equiv u$;
1. Für alle Kanten $e\in E$
2.    if($f(e)>0$)
3.       Füge ${\overleftarrow {e}}$ in $E_{f}$ ein
4.       Setze $u_{f}({\overleftarrow {e}}):=\!\,\!\,f(e)$
5.    if($f(e)<u(e)$)
6.       Füge $e$ in $E_{f}$ ein
7.       Setze $u_{f}(e):=\!\,\!\,u(e)-f(e)$
8. gib aus $N_{f}=(V,E_{f},u_{f},s,t)$

Schichtnetzwerk

Der Level eines Knotens $\operatorname {level} (v){\overset {\underset {\mathrm {def} }{}}{=}}\delta _{f}(s,v)$ ist die Anzahl der Kanten eines kürzesten Weges von $s$ nach $v$ im Residualnetzwerk zum Fluss $f$. Der $i$-te Level eines Graphen ist die Menge aller Knoten mit Level $i$ also $V_{i}{\overset {\underset {\mathrm {def} }{}}{=}}\{v\in V\mid \operatorname {level} (v)=i\}$. Eine Kante $e=(w,v)$ mit Flusswert $f(e)$ heißt nützlich von $w$ nach $v$, falls $f(e)<u(e)$. Falls gilt $f(e)>0$, heißt sie nützlich von $v$ nach $w$. Eine Kante heißt nützlich aus einer Menge, falls sie nützlich von einem Element der Menge in ein Element außerhalb der Menge ist. Analog erklärt man nützlich in eine Menge. Das Schichtnetzwerk oder Levelnetzwerk ${\tilde {N_{f}}}$ zum Fluss $f$ ist ein Teilgraph von $G$ mit

1. ${\tilde {V_{f}}}{\overset {\underset {\mathrm {def} }{}}{=}}V$
2. ${\tilde {E_{f}}}{\overset {\underset {\mathrm {def} }{}}{=}}\{e=(w,v)\in E_{f}\mid \operatorname {level} (w)=\operatorname {level} (v)-1\}$

Schicht- und Residualnetzwerk können in linearer Laufzeit berechnet werden.

Besondere Wege und Flüsse

Ein x-y-Weg oder Pfad $W(x,y)$ ist eine Folge von Kanten, wobei der Ausgangsknoten jeder Kante der Endknoten ihres Vorgängers ist. Die Länge eines Weges $\delta _{W}(x,y)$, auch $dist_{W}(x,y)$ ist die Anzahl der Kanten im Weg.

Die Distanz zwischen $x$ und $y$ ist die Länge eines kürzesten Weges, falls einer existiert, und „unendlich“, falls nicht. Ein Weg im Residualnetzwerk heißt augmentierender Weg; die Bezeichnungen verbessernder Weg oder erhöhender Weg sind auch gebräuchlich. Jeder $s$-$t$-Fluss lässt sich in Flüsse auf $s$-$t$-Wegen und auf Kreisen zerlegen. Genau dann, wenn in einem Netzwerk zu einem $s$-$t$-Fluss kein augmentierender Weg existiert, hat der Fluss maximalen Wert. Diesen Sachverhalt nutzen der Algorithmus von Ford und Fulkerson und der Algorithmus von Edmonds und Karp aus.

Ein Fluss $f$ in einem Netzwerk $(G,u,s,t)$ heißt blockierend, falls in jedem $s$-$t$-Weg in $G$ eine Kante $e$ blockiert, oder auch saturiert, ist, d. h. $f(e)=u(e)$.

Push-Operation

$\operatorname {PUSH} (v,w)$ -> Voraussetzungen: $v\in V$ hat Exzess, $u_{f}(v,w)>0$ und $\operatorname {h} (v)=\operatorname {h} (w)+1$ -> Beschreibung: Schiebe $d_{f}(v,w){\overset {\underset {\mathrm {def} }{}}{=}}min\{\operatorname {ex} (v),u_{f}(v,w)\}$ Einheiten Fluss von $v$ nach $w$ 1. $d_{f}(v,w)\leftarrow min\{\operatorname {ex} (v),u_{f}(v,w)\}$ 2. $f(v,w)\leftarrow f(v,w)+d_{f}(v,w)$ 3. $f(w,v)\leftarrow -f(v,w)$ 4. $\operatorname {ex} (v)\leftarrow \operatorname {ex} (v)-d_{f}(v,w)$ 5. $\operatorname {ex} (w)\leftarrow \operatorname {ex} (w)+d_{f}(v,w)$

Lift-Operation

$\operatorname {LIFT} (v)$ Voraussetzungen: $v\in V$ hat Exzess und es gilt für beliebige $w\in V$: $(v,w)\in E_{f}\Rightarrow \operatorname {h} (v)\leq \operatorname {h} (w)$ Beschreibung: inkrementiere die Höhe von $v$ 1. $\operatorname {h} (v)\leftarrow 1+min\{\operatorname {h} (w)\mid (v,w)\in E_{f}\}$

Präflüsse

$s$-$t$-Präflüsse, oder auch Vorflüsse, (engl. preflow) sind eine Verallgemeinerung von $s$-$t$-Flüssen. Dieser Begriff ist nur bei komplexeren (und wesentlich effizienteren) Flussalgorithmen von Bedeutung.

Ein $s$-$t$-Präfluss ist eine Funktion $f\colon A\rightarrow \mathbb {R} _{+}$ mit Kapazitätskonformität wie oben und folgender Abschwächung des Flusserhalts:

$\forall u\in V\setminus \{s\}:\operatorname {ex} (u)\geq 0$

Das bedeutet, nur den Knoten $s$ darf mehr Fluss verlassen, als ihn erreicht. Ein $s$-$t$-Präfluss hat Überschuss in einem Knoten, oder auch Overflow, falls sein Überschuss (wie oben) echt größer als Null ist. Das Residualnetzwerk wird analog zu oben gebildet.

Die Höhenfunktion oder Distanzmarkierung in einem Netzwerk mit $s$-$t$-Präfluss $f$ ist eine Abbildung $\operatorname {h} \colon V\rightarrow \mathbb {N} _{0}$ mit $\operatorname {h} (s)=|V|$, $\operatorname {h} (t)=0$ und $\operatorname {h} (v)\leq \operatorname {h} (w)+1$ für alle Kanten $e=(v,w)\in E_{f}$.

Ferner erklärt man die Operationen Push und Lift algorithmisch, so wie rechts beschrieben. Mit diesen Mitteln kann man Preflow-Push-Algorithmen entwerfen und untersuchen, etwa den Goldberg-Tarjan-Algorithmus (nach Andrew Goldberg und Robert Tarjan). Bei diesen Algorithmen kann man die Datenstrukturen während der Algorithmus läuft nicht als $s$-$t$-Fluss interpretieren. Die Methode von Goldberg und Tarjan initialisiert einen Präfluss und terminiert, falls gewisse Manipulationen der Struktur einen $s$-$t$-Fluss liefern. Das ist dort stets nach endlich vielen Schritten der Fall und dieser $s$-$t$-Fluss ist dann stets maximal.

Algorithmen

Der Algorithmus von Ford und Fulkerson sucht nach und nach augmentierende Wege, also Wege im Residualnetzwerk, und erhöht dort entlang. Dieses Verfahren klappt genau dann, wenn dieser Algorithmus terminiert, also in die Situation kommt, dass es tatsächlich keine augmentierenden Wege mehr gibt. Dann kann man nämlich die maximale von $s$ aus im Residualnetz erreichbare Knotenmenge betrachten. Diese definiert einen $s$-$t$-Schnitt, dessen Kapazität dem Flusswert gleicht.

Um das Terminieren aber zu sichern, kann man ein Argument über die algebraische Struktur der Kapazitätswerte heranziehen. Sind es nichtnegative ganze Zahlen, ist der Wert eines maximalen $s$-$t$-Flusses eine ganze Zahl. Zudem gibt es wenigstens einen maximalen s-t-Fluss, der kantenweise lediglich ganzzahlige Werte annimmt. Für jeden maximalen s-t-Fluss muss das nicht der Fall sein. Weil jedes Augmentieren entlang eines $s$-$t$-Weges den Wert des $s$-$t$-Flusses um einen ganzzahligen Schritt, also um mindestens 1 erhöht, ist die Terminierung nach endlich vielen Schritten in dem Fall gesichert. Eine obere Schranke der Laufzeit des Algorithmus kann dann von den Werten der Kapazitäten abhängen. Die Laufzeit kann dann in Bezug auf Anzahl der Knoten und Kanten beliebig groß sein, je nachdem welche Kapazitäten auf den Kanten gegeben sind. Sind die Kapazitäten nichtnegative rationale Zahlen, terminiert der Ford-Fulkerson-Algorithmus ebenfalls, weil das Netzwerk dann algorithmisch äquivalent zu einem Netzwerk ist, bei dem die Kapazitäten mit dem Hauptnenner multipliziert sind, also nur ganzzahlige Kapazitäten auftreten. Bei reellen, irrationalen Kapazitäten muss der Algorithmus jedoch nicht terminieren und noch nicht einmal gegen einen maximalen $s$-$t$-Fluss konvergieren.

Der Edmonds-Karp-Algorithmus stellt eine Weiterentwicklung der Methode von Ford und Fulkerson dar: Er funktioniert ganz analog, sucht aber augmentierende Wege, die bezüglich Kantenanzahl minimal sind. Das geht mit einer Breitensuche jeweils in linearer Laufzeit. Der Edmonds-Karp-Algorithmus terminiert auch bei beliebigen reellen Kantenkapazitäten. Darüber hinaus ist seine Laufzeit ${\mathcal {O}}(|V|\cdot |E|^{2})$, also im Allgemeinen größenordnungsmäßig deutlich besser als der Ford-Fulkerson-Algorithmus.

Der Dinic-Algorithmus basiert auf einer weiteren Beobachtung. Sucht man im Residualnetzwerk nach einem augmentierenden Weg, kann es passieren, dass man in Sackgassen gerät, also zu einem Knoten, von dem aus $t$ gar nicht erreichbar ist. Die Idee ist, das Netzwerk zu schichten, also in Gruppen zusammenzufassen, die dieselbe Entfernung zu $s$ haben, also solche Sackgassen eliminiert sind. In diesem Schichtnetzwerken nutzt man dann ferner aus, dass eine Suche nicht nur einen Weg liefert, sondern immer auch ohne zusätzlichen Aufwand einen Wegbaum. Entlang dieses Baumes kann man dann Fluss schicken und das Netzwerk blockieren. Das geht alles elementar in ${\mathcal {O}}(|V|\cdot |E|)$ mit einer modifizierten Tiefensuche. In der nächsten Iteration hat man dann die Situation, wenigstens eine Schicht mehr zu benötigen, weil die alte Schichtung blockiert ist. Das Argument zur Beschränkung der Schichtzahl auf höchstens $|V|-1$ Stück liefert eine Schranke an die Anzahl der sogenannten Phasendurchläufe des Algorithmus, also die Anzahl der Schleifeniterationen. Somit ergibt sich eine Laufzeit von ${\mathcal {O}}(|V|^{2}\cdot |E|)$.

Die folgende Tabelle gibt eine Übersicht der entwickelten Fluss-Algorithmen und ihrer Laufzeiten:

Max-Flow Algorithmen nach Veröffentlichung

Jahr	Autor(en)	Name	Laufzeiten
1956	Ford, Fulkerson	Algorithmus von Ford und Fulkerson	${\mathcal {O}}\left(m\cdot n\cdot u_{\max }\right)$, falls alle Kapazitäten ganzzahlig sind
1969	Edmonds, Karp	Algorithmus von Edmonds und Karp	${\mathcal {O}}\left(m^{2}\cdot n\right)$
1970	Dinic	Algorithmus von Dinic	${\mathcal {O}}\left(m\cdot n^{2}\right)$
1973	Dinic, Gabow		${\mathcal {O}}\left(m\cdot n\cdot \log \left(u_{\max }\right)\right)$
1974	Karzanov		${\mathcal {O}}\left(n^{3}\right)$
1977	Cherkassky		${\mathcal {O}}\left(n^{2}\cdot {\sqrt {m}}\right)$
1980	Galil, Naamad		${\mathcal {O}}\left(m\cdot n\cdot \log \left(n\right)^{2}\right)$
1983	Sleator, Tarjan		${\mathcal {O}}\left(m\cdot n\cdot \log \left(n\right)\right)$
1986	Goldberg, Tarjan	Goldberg-Tarjan-Algorithmus	${\mathcal {O}}\left(m\cdot n\cdot \log \left({\frac {n^{2}}{m}}\right)\right)$
1987	Ahuja, Orlin		${\mathcal {O}}\left(m\cdot n+n^{2}\cdot \log \left(u_{\max }\right)\right)$
1987	Ahuja, Orlin, Tarjan		${\mathcal {O}}\left(m\cdot n\cdot \log \left(2+{\frac {n\cdot {\sqrt {\log(u_{\max })}}}{m}}\right)\right)$
1990	Cheriyan, Hagerup, Mehlhorn		${\mathcal {O}}\left({\frac {n^{3}}{\log \left(n\right)}}\right)$
1990	Alon		${\mathcal {O}}\left(m\cdot n+{\sqrt[{3}]{n^{8}}}\cdot \log \left(n\right)\right)$
1992	King, Rao, Tarjan		${\mathcal {O}}\left(m\cdot n+n^{2+e}\right)$
1993	Philipps, Westbrook		${\mathcal {O}}\left(m\cdot n\cdot \log _{\frac {m}{n}}\left(n\right)+n^{2}\cdot \log \left(n\right)^{2+e}\right)$
1994	King, Rao, Tarjan		${\mathcal {O}}\left(m\cdot n\cdot \log _{\frac {m}{n\cdot \log(n)}}(n)\right)$
1997	Goldberg, Rao		${\mathcal {O}}\left(\min\{{\sqrt {m}},{\sqrt[{3}]{n^{2}}}\}\cdot m\cdot \log \left({\frac {n^{2}}{m}}\right)\cdot \log(u_{\max })\right)$
2012	Orlin, King, Rao, Tarjan		${\mathcal {O}}\left(n\cdot m\right)$
Legende: $n=|V|=$ „Anzahl der Knoten“ $m=|E|=$ „Anzahl der Kanten“ $u_{\max }=$ „Maximum der Kapazitätsfunktion $u$“

Formulierungen als lineares Programm

Das Problem, den Flusswert $|f|$ zu maximieren, lässt sich ebenfalls als lineares Optimierungsproblem beschreiben. Wählt man beispielsweise eine Variable $x_{e}$ für jede Kante $e\in E$, welche den Fluss $f(e)$ auf der Kante misst, so ergibt sich das folgende Programm:

${\begin{aligned}\max &\sum _{e\in \operatorname {\delta ^{+}} (s)}x_{e}-\sum _{e\in \operatorname {\delta ^{-}} (s)}x_{e}\\{\text{so dass }}&\forall v\in V\setminus \{s,t\}\colon \;\sum _{e\in \operatorname {\delta ^{-}} (v)}x_{e}=\sum _{e\in \operatorname {\delta ^{+}} (v)}x_{e}\\&\forall \;e\in E\colon \;x_{e}\geq 0\;\;\\&\forall \;e\in E\colon \;x_{e}\leq u_{e}\\\end{aligned}}$

Eine alternative Formulierung erhält man, wenn man für jeden $s$-$t$-Pfad $P$ eine Variable $x_{P}$ einführt, welche den Fluss auf dem entsprechenden Pfad bezeichnet. Es ergibt sich daraus das folgende Programm:

${\begin{aligned}\max &\sum _{P\in {\mathcal {P}}_{(s,t)}}x_{P}\\{\text{so dass }}&\forall \;e\in E\colon \;\sum _{P\in {\mathcal {P}}_{(s,t)},\;e\in P}x_{P}\leq u_{e}\\&\forall \;P\in {\mathcal {P}}_{(s,t)}\colon \;x_{P}\geq 0\end{aligned}}$

Dabei bezeichnet ${\mathcal {P}}_{(s,t)}$ die Menge aller Pfade von $s$ nach $t$.

Die zweite Formulierung erscheint zunächst ungünstig, da die Anzahl der $s$-$t$-Pfade im Allgemeinen exponentiell mit der Anzahl der Knoten und Kanten wächst. Trotzdem kann diese Formulierung durch Spaltengenerierung effizient, also in Polynomialzeit gelöst werden.

Die beiden Formulierungen haben zusätzlich die Eigenschaft, dass die Matrizen, welche die Nebenbedingungen beschreiben, total unimodular sind. Damit ist jede Optimallösung der beiden Programme ganzzahlig, sofern die Kapazitäten $u_{e}$ ganzzahlig sind.

Es ist zudem lehrreich, sich die Dualisierungen der obigen Programme anzusehen. Für die pfadbasierte Formulierung ist das duale Programm beispielsweise gegeben durch:

${\begin{aligned}\min &\sum _{e\in E}u_{e}y_{e}\\{\text{so dass }}&\forall \;P\in {\mathcal {P}}_{(s,t)}\colon \;\sum _{e\in P}y_{e}\geq 1\\&\forall \;e\in E\colon \;y_{e}\geq 0\end{aligned}}$

Das duale Programm ist ebenfalls total unimodular. Dies impliziert, dass die Optimallösung des dualen Programms ein $0/1$-Vektor mit $|E|$ Einträgen ist. Für jeden zulässigen $0/1$-Vektor $y$ entspricht außerdem die Menge $\{e\in E\,:\,y_{e}=1\}$ einem $s$-$t$-Schnitt. Damit entspricht die Optimallösung des dualen Programms einem $s$-$t$-Schnitt minimaler Kapazität. Hieraus folgt durch den starken Dualitätssatz der linearen Optimierung das Max-Flow-Min-Cut-Theorem.

Verallgemeinerungen

Zu dem Problem gibt es einige wesentliche Verallgemeinerungen. Als erstes kann man anstelle von Flüssen zwischen einer Quelle beziehungsweise Senke solche zwischen Gebieten betrachten. Dazu gibt man sich eine gewisse Menge von Versorgern $S$ und eine Menge von Empfängern $T$ vor, sowie einen Graphen und Kapazitäten. Das Problem ist nicht schwerer als Max-Flow und kann entweder durch Vor- und Nachschalten von Zusatzknoten oder durch Übergang zum Quotientengraphen $G/_{S\cup T}$ auf Max-Flow reduziert werden.

Andererseits kann man die Gültigkeit der den Kanten zugewiesenen Kapazitäten auf eine gewisse Umgebung der Kante ausweiten, wobei für ein festgehaltenes $d\in \mathbb {N}$ eine $d$-Umgebung die Menge von Knoten und Kanten ist, die $d$ Elemente von der Kante entfernt liegen. Der Spezialfall $d=0$ entspricht gerade dem maximalen Flussproblem. Der Fall $d=1$ entspricht dem maximalen Flussproblem mit Knotenkapazitäten. Das kann auf Max-Flow reduziert werden, indem die Knoten durch ein Gebilde, wie im Bild ersetzt werden. Dabei wird die Kantenzahl nicht konstant verändert, also die Komplexität des Problems erhöht. Es existieren aber Lösungen für Max-Flow, deren Komplexität streng von den Knoten abhängt, deren Zahl sich höchstens um den konstanten Faktor 2 ändert.

Für den Fall $d\geq 3$ kann man beweisen, dass das Problem NP-vollständig ist und daher vermutlich nicht in polynomieller Zeit lösbar ist (es sei denn $P=NP$). Für den Fall $d=2$ wurde ein polynomieller Algorithmus gefunden.

Anwendung

Praktische Anwendungen

Diese letzte Verallgemeinerung ist motiviert durch Probleme bei der Verkabelung von VLSI-Chips, wo es aufwändig ist, in eine gewisse Nähe von gelegten Kabeln weitere zu setzen.

Die Flusstheorie hat sich historisch ausgehend von Problemen aus der Anwendung entwickelt. Allgemein ist man von der Situation ausgegangen, ein Fluid, also ein beliebig in Untergegenstände zerlegbaren Gegenstand, auf verschiedenen Wegen durch eine Welt räumlich zu verlagern – etwa elektrische Energie über ein Stromnetzwerk von einer Quelle an einen Bedarfsort, oder Daten durch ein Datennetzwerk von einem Sender zu einem Empfänger. Auch abstrakte Gegenstände wie „einander kennen“ kann man modellieren. Durch maximale Flüsse in einem sozialen Netzwerk kann man dann ein Maß dafür erhalten, wie stark zwei (Mengen von) Personen miteinander vernetzt sind.

Bipartiter Graph mit der Knotenmenge A (rot) und B (grün) und der ergänzten Quelle s und Senke t

Theoretische Anwendungen

Eine naheliegende und natürliche Anwendung hat die Flusstheorie bei der Transversalentheorie, die sich auf sehr natürliche Art und Weise in die Theorie der Flüsse einbetten lässt. Einen umfassenden Ansatz, das zu tun, hat Ford 1962 in einem Standardwerk formuliert.

Auch viele kombinatorische Probleme auf Graphen, wie bipartite Matchings, lassen sich leicht in ein geeignetes Flussproblem überführen (siehe Bild) und dort schnell lösen. Eine weitere Anwendung ist das effiziente Ermitteln der Knotenzusammenhangszahl, Kantenzusammenhangszahl oder Bogenzusammenhangszahl. Durch das Lemma von Tutte (nach William Thomas Tutte) werden zudem Anwendungen erweiterter Flusstheorie (sogenannten gruppenwertigen Flüssen) und Färbbarkeitsaussagen deutlich. Einige Vermutungen von ihm zur Existenz von k-Flüssen in planaren Graphen hätten starke theoretische Implikationen.

Literatur

• Bernhard Korte, Jens Vygen: Kombinatorische Optimierung: Theorie und Algorithmen. Aus dem Englischen von Rabe von Randow. Springer-Verlag, Berlin Heidelberg 2008, ISBN 978-3-540-76918-7
• Alexander Schrijver: Combinatorial Optimization: Polyhedra and Efficiency, Springer-Verlag, 2003, ISBN 3-540-44389-4
• Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, Clifford Stein: Introduction to Algorithms. 2. Auflage. MIT Press, Cambridge MA 2001, ISBN 0-262-03293-7. 
• Lester Randolph Ford junior, Delbert Ray Fulkerson: Flows in Networks. 1962, ISBN 0-691-07962-5, ISBN 978-0-691-07962-2.