Форд-Фулкерсонов алгоритам

Форд-Фулкерсон метод (назван по Л. Р. Форду, мл. и Д. Р. Фулкерсону је алгоритам који рачуна максимални проток у транспортној мрежи. Објављен је 1956. Име "Форд-Фулкерсон" се често користи и за Едмондс-Карп алгоритам, који је специјализација Форд-Фулкерсона.

Основна идеја је једноставна. Докле год постоји путања од извора (почетни чвор) до понора (крајњи чвор), са доступним капацитетима на свим гранама путање, слаћемо проток дуж једне од ових путања. Тада проналазимо нову путању итд. Путања се доступним капацитетом се назива појачавајућа путања.

Алгоритам

Нека је $G(V,E)$ граф и нека за сваку грану од $u$ до $v$ $c(u,v)$ представља капацитет, а $f(u,v)$ проток дуж гране. Ми желимо да пронађемо максималан проток од извора $s$ до понора $t$. Након сваког корака у алгоритму, следећа тврђења су тачна:

Ограничења капацитета:	$\forall (u,v)\in E\ f(u,v)\leq c(u,v)$	Проток кроз грану не може премашити њен капацитет.
Коса симетрија:	$\forall (u,v)\in E\ f(u,v)=-f(v,u)$	Укупан проток од $u$ до $v$ мора бити супротан од протока од $v$ до $u$ (видети пример).
Очување протока:	$\forall u\in V:u\neq s{\text{ and }}u\neq t\Rightarrow \sum _{w\in V}f(u,w)=0$	Под условом да $u$ није $s$ или $t$. Укупан проток ка неком чвору је нула, осим ако чвор није извор, који "ствара" проток, или понор, који "троши" проток.

Ово значи да је проток кроз мрежу дозвољени проток након сваког понављања у алгоритму. Дефинишемо резидуалну мрежу $G_{f}(V,E_{f})$ као мрежу капацитета $c_{f}(u,v)=c(u,v)-f(u,v)$ и без протока. Обратите пажњу да може да се деси да проток од $v$ до $u$ буде дозвољен у резидуалној мрежи, иако недозвољен у почетној мрежи: ако $f(u,v)>0$ и $c(v,u)=0$ тада $c_{f}(v,u)=c(v,u)-f(v,u)=f(u,v)>0$.

Алгоритам Форд-Фулкерсон

Улаз Граф $G$ са капацитетима $c$, извором $s$ и понором $t$

Излаз Проток $f$ од $s$ до $t$ који је максималан

1. $f(u,v)\leftarrow 0$ за све гране $(u,v)$
2. Док постоји путања $p$ од $s$ до $t$ у $G_{f}$, таква да је $c_{f}(u,v)>0$ за све гране $(u,v)\in p$:
   1. Пронађи $c_{f}(p)=\min\{c_{f}(u,v):(u,v)\in p\}$
   2. За сваку грану$(u,v)\in p$
      1. $f(u,v)\leftarrow f(u,v)+c_{f}(p)$ (Пошаљи проток дуж путање)
      2. $f(v,u)\leftarrow f(v,u)-c_{f}(p)$ (Проток се може "вратити" касније)

Путања из корака 2 се може пронаћи уз помоћ претраге у ширину или претраге у дубину у графу $G_{f}(V,E_{f})$. Уколико користите претрагу у ширину, онда се зове Едмондс-Карп алгоритам.

Када се више ниједна путања не може пронаћи, тада се из $s$ не може доћи до $t$ у резидуалној мрежи. Ако је $S$ скуп чворова до којих се може доћи у резидуалној мрежи из $s$, онда је укупан капацитет почетне мреже грана од $S$ до $V$ са једне стране једнак укупном протоку који смо пронашли од $s$ до $t$, а са друге стране служи као горња граница за све такве протоке. То доказује да је проток који смо пронашли максималан.

Главни пример

Следећи пример показује прве кораке Форд-Фулкерсона у проточној мрежи са 4 чвора, извором $A$ и понором $D$. Овај пример показује понашање алгоритма у најгорем случају. У сваком кораку се корз мрежу шаље проток од $1$. Да смо искористили претрагу у ширину, само два корака би била потребна.

Путања	Капацитет	Резултујућа мрежа
Почетна мрежа
$A,B,C,D$	$\min(c_{f}(A,B),c_{f}(B,C),c_{f}(C,D))=$ $\min(c(A,B)-f(A,B),c(B,C)-f(B,C),c(C,D)-f(C,D))=$ $\min(1000-0,1-0,1000-0)=1$
$A,C,B,D$	$\min(c_{f}(A,C),c_{f}(C,B),c_{f}(B,D))=$ $\min(C),c(C,B)-f(C,B),c(B,D)-f(B,D))=$ $\min(1000-0,0-(-1),1000-0)=1$
Након још 1998 корака…
Коначни изглед мреже.

Приметите како се проток "гура назад" од $C$ до $B$ када се тражи путања $A,C,B,D$.

Незавршавајући пример

Размотрите мрежу дату десно, са извором $s$, понором $t$ и капацитетима грана $e_{1}$, $e_{2}$ и $e_{3}$ $1$, $r=({\sqrt {5}}-1)/2$ и $1$, а капацитет свих других грана је неко $M\geq 2$. Константа $r$ је одабрана, јер $r^{2}=1-r$. Користимо појачавајуће путање у складу са датом табелом, где је $p_{1}=\{s,v_{4},v_{3},v_{2},v_{1},t\}$, $p_{2}=\{s,v_{2},v_{3},v_{4},t\}$ и $p_{3}=\{s,v_{1},v_{2},v_{3},t\}$.

Корак	Појачавајућа путања	Послат проток	Преостали проток
			$e_{1}$	$e_{2}$	$e_{3}$
0			$r^{0}=1$	$r$	$1$
1	$\{s,v_{2},v_{3},t\}$	$1$	$r^{0}$	$r^{1}$	$0$
2	$p_{1}$	$r^{1}$	$r^{2}$	$0$	$r^{1}$
3	$p_{2}$	$r^{1}$	$r^{2}$	$r^{1}$	$0$
4	$p_{1}$	$r^{2}$	$0$	$r^{3}$	$r^{2}$
5	$p_{3}$	$r^{2}$	$r^{2}$	$r^{3}$	$0$

Обратите пажњу на то да након корака 1, као и након корака 5, преостали капацитет грана $e_{1}$, $e_{2}$ и $e_{3}$ су у облику $r^{n}$, $r^{n+1}$ and $0$, за неко $n\in \mathbb {N}$. Ово значи да можемо користити појачавајуће путање $p_{1}$, $p_{2}$, $p_{1}$ и $p_{3}$ бесконачно много пута и преостали капацитет ових грана ће увек имати исти облик. Укупан проток у мрежи након корака 5 је $1+2(r^{1}+r^{2})$. Ако наставимо да користимо ове појачавајуће путање, укупан проток тежи ка $\textstyle 1+2\sum _{i=1}^{\infty }r^{i}=3+2r$, док је максималан проток $2M+1$. У овом случају се алгоритам никад не завршава, а проток ни не тежи ка максималном протоку.

Додатни примери

Слика 1.1

Слика 1.2 / Иницијализација

Пример 1.

Пронађимо максималан проток за мрежу са Слике 1.1

1. Итерација :

У кораку 1, поставили смо да за сваки чвор претходник и резерва буду једнаки симболу -, да резерва за $a$буде једнака " ∞ " и да је S = {$a$}. Тада имамо мрежу са Слике 1.2

У кораку 2, проверавамо да скуп S није празан и бирамо $a$ из S.

У кораку 3, стављамо да резерва за $b$ буде једнака min(7, ∞) = 7 и да претходник од $b$ буде чвор $a$. Смештамо $b$ у S. Такође стављамо да резерва за $d$ буде једнака min(6, ∞) = 6, а да претходник од $d$ буде једнак $a$. Смештамо $d$ у S.

Кораци 4,5 се не могу применити (4. корак зато што немамо ни једну неправилно оријентисану грану, а 5. корак јер $z$ није означен), па се враћамо на корак 2.

У кораку 2, проверавамо да скуп С није празан, а затим из S бирамо неки чвор, рецимо $b$. Скуп С сада садржи само $d$

У кораку 3, стављамо да резерва за $c$ буде једнака min(3, 7) = 3 и да претходник од $c$ буде чвор $b$. Смештамо $c$ у S тако да је S = {$c$,$d$}. Поново се Кораци 4,5 не могу применити, тако да се враћамо на Корак 2.

У кораку 2, проверавамо да скуп С није празан и бирамо неки чвор, рецимо $c$ из S. Скуп S поново садржи само $d$.

У кораку 3, стављамо резерву за $z$ на min(3,5) = 3 и претходник од $z$ постаје чвор $c$. Не смештамо $z$ у S.

У кораку 4, означили бисмо $d$ али је већ означено.

У кораку 5, видимо да је $z$ означено и користећи функцију претходника, откривамо да имамо ланац $a$ → $b$ → $c$ → $z$ са тежинама грана (7,0) → (3,0) → (5,0) и додајуци 3, резерву за $z$ протоку сваке гране тј. другој кординати гране, добијамо ланац $a$ → $b$ → $c$ → $z$ са тезинама (7,3) → (3,3) → (5,3) што нам даје мрежу са Слике 1.3.

Слика 1.3

Слика 1.4

2. Итерација:

Сада се враћамо на корак 1, где поново подешавамо ознаке и претходнике и нека је S = {$a$}.

У кораку 2, бирамо а из S.

U кораку 3, подешавамо да резерва за $b$ буде једнака min(∞,7-3) = 4 и да претходник од $b$ буде чвор $a$. Смештамо $b$ у S. Такође стављамо да резерва за $d$ буде једнака 6 и стављамо да претходник од $d$ буде чвор $a$. Смештамо $d$ у S.

Кораци 4,5 се не могу применити, тако да се враћамо на корак 2.

У кораку 2, бирамо $b$ из С. Како проток од $b$ до $c$ једнак капацитету гране од $b$ до $c$, не можемо да применимо корак 3 и означимо $c$.

У кораку 2, бирамо $d$ из S.

У кораку 3, подешавамо да резерва за $z$ буде једнака min(6,2) = 2 и да претходник од $z$ буде чвор $d$. Не смештамо $z$ у S.

У кораку 5, видимо да је $z$ означено и користећи функцију претходника, откривамо да имамо ланац $a$ → $d$ → $z$ са тежинама грана (6,0) → (2,0) и додајуци 2, резерву за $z$ протоку сваке гране тј. другој кординати гране, добијамо ланац $a$ → $d$ → $z$ са тежинама грана (6,2) → (2,2) што нам даје мрежу са Слике 1.4.

Слика 1.5

Слика 1.6

3. Итерација:

Сада се враћамо на корак 1 и понављамо поступак док не добијемо ланаc $a$ → $d$ → $c$ → $z$ са тежинама грана (6,2) → (2,0) → (5,3) и додајући 2, резерву од $z$ протоку сваке гране, добијамо ланац $a$ → $d$ → $c$ → $z$ са тежинама грана (6,4) → (2,2) → (5,5) што нам даје Слику 1.5

4. Итерација:

Сада се враћамо на корак 1 где поново поништавамо ознаке и претходнике и постављамо S = {$a$}.

У кораку 2, бирамо $a$ из S.

У кораку 3, као и раније, стављамо да резерва за $b$ буде једнака 4 и да претходник од $d$ буде чвор $a$. Смештамо $b$ у S. Такође стављамо да резерва за $d$ буде једнака 6 - 4 = 2 и смештамо $d$ у S.

Враћамо се на корак 2. Бирамо $b$ из S. Како је проток од $b$ до $c$ једнак капацитету гране од $b$ до $c$, не можемо да означимо $c$, тако да треба да се вратимо на корак 2.

Корак 2, бирамо $d$ из S. Како је проток од $d$ до $c$ једнак њиховом капацитету, не можемо да означимо $c$ и $z$. Поново се враћамо на корак 2, али је скуп S празан, тако да смо завршили.

Коначан проток приказан је на Слици 1.6 и он представља збир протока у свим итерацијама тј. у овом случају 3 + 2 + 2 = 7.

Слика 2.1

[[Датотека:Slika 2.2.png|350п|thumbnail|center|Љ

ПРИМЕР 2. (са неправилно оријентисаном граном)

Пронађимо максималан проток за мрежу са Слике 2.1

1. Итерација :

Овога пута даћемо мање детаља за неколико првих итерација.

У првој итерацији означавамо $a$(-,∞) , $b(a,9)$ , $d(a,8)$ , $c(b,4)$ , $e(b,6)$ , $z(c,4)$. То нам даје пут $a$ - $z$ и добијамо ланац $a$ → $b$ → $c$ → $z$ са тежинама грана (9,0) → (4,0) → (8,0) и додајући 4, резерву од $z$ протоку сваке гране, добијамо ланац $a$ → $b$ → $c$ → $z$ са тежинама грана (9,4) → (4,4) → (8,4) што нам даје Слику 2.2

Слика 2.3

Слика 2.4

2. Итерација :

У другом пролазу означавамо $a$(-,∞), $b(a,5)$, $d(a,8)$, $c(d,4)$, $e(d,8)$, $z(e,7)$. То нам даје пут $a$ - $z$ и добијамо ланац $a$ → $d$ → $e$ → $z$ са тежинама грана (8,0) → (9,0) → (7,0) и додајући 7, резерву од $z$ протоку сваке гране, добијамо ланац $a$ → $d$ → $e$ → $z$ са тежинама грана (8,7) → (9,7) → (7,7) што нам даје Слику 2.3

3. Итерација :

У трећем пролазу означавамо $a$(-,∞) , $b(a,5)$ , $d(a,1)$ , $c(d,1)$ , $e(d,1)$ , $z(c,1)$. То нам даје пут $a$ - $z$ и добијамо ланац $a$ → $d$ → $c$ → $z$ са тежинама грана (8,7) → (4,0) → (8,4) и додајући 1, резерву од $z$ протоку сваке гране, добијамо ланац $a$ → $d$ → $c$ → $z$ са тежинама грана (8,8) → (4,1) → (8,5) што нам даје Слику 2.4.

Слика 2.5

Слика 2.6

4. Итерација :

Од сада постаје интересантно тако да ћемо обратити пажњу на детаље. Означавамо $b(a,5)$ али не можемо да означимо $d$ и смештамо само $b$ у S. Бирајући $b$ из S, не можемо да означимо $c$, али означавамо $e(b,5)$ и смештамо $e$ у S. Бирајући $e$ из S, не можемо да означимо $z$, али како $d$ није означено, можемо то да учинимо . Како грана ($d$,$e$) није правилно оријентисана, допуштамо да резерва од $d$ буде једнака min(7,5) = 5. Стављамо да претходник од $d$ буде једнак $e$ и смештамо $d$ у S (Корак 4. у Поступку). Бирајући $d$ из S, једини избор који имамо је да означимо $c(d,3)$ и сместимо $c$ у S. Бирамо $c$ из S и означавамо $z(c,3)$ .

То нам даје пут $a$ - $z$ и добијамо ланац $a$ → $b$ → $e$ ← $d$ → $c$ → $z$ са тежинама грана (9,4) → (6,0) → (9,7) ← (4,1) → (8,5) и како је резерва од $z$ једнака 3, сваком протоку додајемо 3, осим оном за грану ($d$,$e$). Пошто она није правилно оријентисана, одузимамо 3 од протока ове гране и добијамо ланац $a$ → $b$ → $e$ ← $d$ → $c$ → $z$ са тежинама грана (9,7) → (6,3) → (9,4) ← (4,4) → (8,8) што нам даје Слику 2.5.

5. Итерација :

Сада можемо да почнемо завршни пролаз. Почињемо са S = {$a$}. Уклањамо $a$ из S, означавамо $b(a,2)$ и смештамо $b$ у S. Бирамо $b$ из S, означавамо $e(b,2)$, $c$ не можемо да означимо из $b$. Смештамо $e$ у S. Бирамо $e$ из S , означавамо $d(e,2)$ пошто је резерва од $d$ једнака минимуму протока гране ($d$,$e$) и резерва од $d$ (Корак 4. у Поступку). Затим смештамо $d$ у S. Потом бирамо $d$ из S, али не можемо да извршимо било који од преосталих корака, па се враћамо на корак 2. Али скуп С је празан, па завршавамо. Сада имамо Слику 2.6.

Коначан проток приказан је на Слици 2.6 и он представља збир протока у свим итерацијама тј. у овом случају 4 + 7 + 1 + 3 = 15.

Сложеност

Додајући појачавајуће путање протоку који је већ утврђен у графу доћи ћемо до максималног протока када више не будемо могли да пронађемо нове појачавајуће путање. Међутим, не постоји сигурност да ће се до ове ситуације икад доћи, тако да је једино сигурно да уколико се алгоритам заустави да ће одговор бити тачан. У случају да алгоритам ради бесконачно, може се десити да проток уопште не конвергира ка максималном протоку. Али, ова ситуација се догађа само са ирационалним вредностима протока. Када су капацитети цели бројеви, време извршавања је ограничено са $O(Ef)$ (видети велико О), где је $E$ број грана у графу и $f$ максималан проток графа. Ово је зато што се појачавајућа путања може пронаћи у $O(E)$ времена и повећати проток за целобројну вредност која је минимум $1$.

Варијација Форд-Фулкерсон алгоритма који гарантује завршетак и временски је независна од максималног протока у графу је Едмондс-Карп алгоритам који раду времену $O(VE^{2})$.

Пајтон имплементација

class Edge(object):
    def __init__(self, u, v, w):
        self.source = u
        self.sink = v  
        self.capacity = w
    def __repr__(self):
        return "%s->%s:%s" % (self.source, self.sink, self.capacity)

class FlowNetwork(object):
    def __init__(self):
        self.adj = {}
        self.flow = {}
 
    def add_vertex(self, vertex):
        self.adj[vertex] = []
 
    def get_edges(self, v):
        return self.adj[v]
 
    def add_edge(self, u, v, w=0):
        if u == v:
            raise ValueError("u == v")
        edge = Edge(u,v,w)
        redge = Edge(v,u,0)
        edge.redge = redge
        redge.redge = edge
        self.adj[u].append(edge)
        self.adj[v].append(redge)
        self.flow[edge] = 0
        self.flow[redge] = 0
 
    def find_path(self, source, sink, path):
        if source == sink:
            return path
        for edge in self.get_edges(source):
            residual = edge.capacity - self.flow[edge]
            if residual > 0 and edge not in path:
                result = self.find_path( edge.sink, sink, path + [edge]) 
                if result != None:
                    return result
 
    def max_flow(self, source, sink):
        path = self.find_path(source, sink, [])
        while path != None:
            residuals = [edge.capacity - self.flow[edge] for edge in path]
            flow = min(residuals)
            for edge in path:
                self.flow[edge] += flow
                self.flow[edge.redge] -= flow
            path = self.find_path(source, sink, [])
        return sum(self.flow[edge] for edge in self.get_edges(source))

Јава имплементација

import java.util.*;
import java.lang.*;
import java.io.*;
import java.util.LinkedList;
 
class MaxFlow
{
    static final int V = 6; //Broj cvorova grafa
 
    /* Vraca true ako postoji put od pocetnog
        cvora do krajnjeg (cilja) u grafu, 
        takodje popunjava parent[] da zapamti put
       */
    boolean bfs(int rGraph[][], int s, int t, int parent[])
    {
        // Napravi listu posecenih elemenata, na pocetku stavi da su svi
        // neposeceni
        boolean visited[] = new boolean[V];
        for(int i=0; i<V; ++i)
            visited[i]=false;
 
        LinkedList<Integer> queue = new LinkedList<Integer>();
        queue.add(s);
        visited[s] = true;
        parent[s]=-1;
 
        // BFS pretraga
        while (queue.size()!=0)
        {
            int u = queue.poll();
 
            for (int v=0; v<V; v++)
            {
                if (visited[v]==false && rGraph[u][v] > 0)
                {
                    queue.add(v);
                    parent[v] = u;
                    visited[v] = true;
                }
            }
        }
 
        // Ako smo dosli do ciljnog cvora u BFS-u onda 
        // vrati true u suprotnom vrati false
        return (visited[t] == true);
    }
 
    // Vraca maksimalni protok od s do t za dati graf
    int fordFulkerson(int graph[][], int s, int t)
    {
        int u, v;
 
        int rGraph[][] = new int[V][V];
 
        for (u = 0; u < V; u++)
            for (v = 0; v < V; v++)
                rGraph[u][v] = graph[u][v];
 
        // Lista je popunjena u BFS- u i pamti puteve
        int parent[] = new int[V];
 
        int max_flow = 0;  // na pocetku je protok 0
 
        // Augmentuj protok dokle god postoji put od izvora do cilja 
        while (bfs(rGraph, s, t, parent))
        {
           
            // Pronadji maksimalan protok za pronadjeni put od s do t
            int path_flow = Integer.MAX_VALUE;
            for (v=t; v!=s; v=parent[v])
            {
                u = parent[v];
                path_flow = Math.min(path_flow, rGraph[u][v]);
            }
 
            // Povecaj kapacitete grana i umanji ako ima onih sa obrnutim smerom, 
            // duz nadjene putanje 
            for (v=t; v != s; v=parent[v])
            {
                u = parent[v];
                rGraph[u][v] -= path_flow;
                rGraph[v][u] += path_flow;
            }
 
            // Dodajemo trenutni protok konacnom maksimalnom protoku kroz mrezu
            max_flow += path_flow;
        }
 
        // Vracamo konacan max protok
        return max_flow;
    }
 
    // Main metod za testiranje algoritma
    public static void main (String[] args) throws java.lang.Exception
    {
        // Kreiramo proizvoljan graf
        int graph[][] =new int[][] { {0, 16, 13, 0, 0, 0},
                                     {0, 0, 10, 12, 0, 0},
                                     {0, 4, 0, 0, 14, 0},
                                     {0, 0, 9, 0, 0, 20},
                                     {0, 0, 0, 7, 0, 4},
                                     {0, 0, 0, 0, 0, 0}
                                   };
        MaxFlow m = new MaxFlow();
 
        System.out.println("Maksimalan protok kroz mrezu je  " +
                           m.fordFulkerson(graph, 0, 5));
 
    }
}

C++ имплементација

#include <iostream>
#include <limits.h>
#include <string.h>
#include <queue>
using namespace std;
 
// Broj cvorova u grafu
#define V 6
 
  /* Vraca true ako postoji put od pocetnog
        cvora do krajnjeg (cilja) u grafu, 
        takodje popunjava parent[] da zapamti put
       */
bool bfs(int rGraph[V][V], int s, int t, int parent[])
{
    // Napravi listu posecenih elemenata, na pocetku stavi da su svi
    // neposeceni
    bool visited[V];
    memset(visited, 0, sizeof(visited));
 
    queue <int> q;
    q.push(s);
    visited[s] = true;
    parent[s] = -1;
 
    // BFS pretraga
    while (!q.empty())
    {
        int u = q.front();
        q.pop();
 
        for (int v=0; v<V; v++)
        {
            if (visited[v]==false && rGraph[u][v] > 0)
            {
                q.push(v);
                parent[v] = u;
                visited[v] = true;
            }
        }
    }
 
   // Ako smo dosli do ciljnog cvora u BFS-u onda 
   // vrati true u suprotnom vrati false
    return (visited[t] == true);
}
 
 // Vraca maksimalni protok od s do t za dati graf
int fordFulkerson(int graph[V][V], int s, int t)
{
    int u, v;
 
    int rGraph[V][V]; 
    for (u = 0; u < V; u++)
        for (v = 0; v < V; v++)
             rGraph[u][v] = graph[u][v];
 
    int parent[V]; // Lista je popunjena u BFS- u i pamti puteve

 
    int max_flow = 0;  
 
     // Augmentuj protok dokle god postoji put od izvora do cilja 
    while (bfs(rGraph, s, t, parent))
    {
       // Pronadji maksimalan protok za pronadjeni put od s do t
        int path_flow = INT_MAX;
        for (v=t; v!=s; v=parent[v])
        {
            u = parent[v];
            path_flow = min(path_flow, rGraph[u][v]);
        }
 
        // Povecaj kapacitete grana i umanji ako ima onih sa obrnutim smerom, 
        // duz nadjene putanje 
        for (v=t; v != s; v=parent[v])
        {
            u = parent[v];
            rGraph[u][v] -= path_flow;
            rGraph[v][u] += path_flow;
        }
 
        // Dodaj trenutni protok maksimalnom protoku
        max_flow += path_flow;
    }
 
    // Vrati max protok
    return max_flow;
}
 
// Main funkcija za testiranje algoritma
int main()
{

    int graph[V][V] = { {0, 16, 13, 0, 0, 0},
                        {0, 0, 10, 12, 0, 0},
                        {0, 4, 0, 0, 14, 0},
                        {0, 0, 9, 0, 0, 20},
                        {0, 0, 0, 7, 0, 4},
                        {0, 0, 0, 0, 0, 0}
                      };
 
    cout << "Maksimalan protok kroz mrezu je :  " << fordFulkerson(graph, 0, 5);
 
    return 0;
}

Литература

• Heineman, George T.; Pollice, Gary; Selkow, Stanley (2008). „Chapter 8:Network Flow Algorithms”. Algorithms in a Nutshell. Oreilly Media. стр. 226—250. ISBN 978-0-596-51624-6. 
• Anderson, James A. (2004). „Chapter 16:Networks - Ford–Fulkerson algorithm”. Discrete Mathematics with Combinatorics (2nd Edition). Pearson Education. стр. 783-789. ISBN 978-0130457912. 
• Cormen, Thomas H.; Leiserson, Charles E.; Rivest, Ronald L.; Stein, Clifford (2001). „Section 26.2: The Ford-Fulkerson method”. Introduction to Algorithms (Second изд.). MIT Press and McGraw-Hill. стр. 651-664. ISBN 978-0-262-03293-3. 
• Ford, L. R.; Fulkerson, D. R. (1956). „Maximal flow through a network”. Canadian Journal of Mathematics. 8: 399—404. 

Спољашње везе

• Another Java animation
• Java Web Start application
• Ford-Fulkerson Algorithm for Maximum Flow Problem
• Ford Fulkerson algorithm for Max Flow
• Courses Network Flow