Implementation of

Ford Fulkerson
algorithm.
 Mahavir Education Trust's

SHAH & ANCHOR KUTCHHI ENGINEERING COLLEGE

Chembur, Mumbai - 400 088

UG Program in Electronics & Computer Science

Experiment No. 6
Aim: Implementation of Ford Fulkerson algorithm.
Required Software/ Software Tool:
- Windows Operating System
-C/C++/JAVA

Theory:
Ford-Fulkerson algorithm is a greedy approach for calculating the maximum possible flow in
a network or a graph.
A term, flow network, is used to describe a network of vertices and edges with a source (S)
and a sink (T). Each vertex, except S and T, can receive and send an equal amount of stuff
through it. S can only send, and T can only receive stuff. We can visualize the understanding
of the algorithm using a flow of liquid inside a network of pipes of different capacities. Each
pipe has a certain capacity of liquid it can transfer at an instance. For this algorithm, we are
going to find how much liquid can be flowed from the source to the sink at an instance using
the network.

Let take a example:

 Mahavir Education Trust's

SHAH & ANCHOR KUTCHHI ENGINEERING COLLEGE

Chembur, Mumbai - 400 088

UG Program in Electronics & Computer Science

Select any arbitrary path from S to T. In this step, we have selected path S-A-B-T

The minimum capacity among the three edges is 2 (B-T). Based on this, update
the flow/capacity for each path.

Select another path S-D-C-T. The minimum capacity among these edges is 3 (S-D)

Update the capacities according to this.

 Mahavir Education Trust's

SHAH & ANCHOR KUTCHHI ENGINEERING COLLEGE

Chembur, Mumbai - 400 088

UG Program in Electronics & Computer Science

Now, let us consider the reverse-path B-D as well. Selecting path S-A-B-D-C-T. The
minimum residual capacity among the edges is 1 (D-C).

Updating the capacities.

The capacity for forward and reverse paths are considered separately.
Adding all the flows = 2 + 3 + 1 = 6, which is the maximum possible flow on the flow
network.

Algorithm:
Augmenting Path-It is the path available in a flow network.
Residual Graph-It represents the flow network that has additional possible flow.
Residual Capacity-It is the capacity of the edge after subtracting the flow from the
maximum capacity.
 Mahavir Education Trust's

SHAH & ANCHOR KUTCHHI ENGINEERING COLLEGE

Chembur, Mumbai - 400 088

UG Program in Electronics & Computer Science

1. Initialize the flow in all the edges to 0.

2. While there is an augmenting path between the source and the sink, add this path to
the flow.
3. Update the residual graph.

Implementing the Solution Writing Source Code:

//Tanishka Mayekar
#include <stdio.h>
#define A 0
#define B 1
#define C 2
#define MAX_NODES 1000
#define O 1000000000

int n;
int e;
int capacity[MAX_NODES][MAX_NODES];
int flow[MAX_NODES][MAX_NODES];
int color[MAX_NODES];
int pred[MAX_NODES];

int min(int x, int y) {

return x < y ? x : y;
}

int head, tail;

int q[MAX_NODES + 2];
 Mahavir Education Trust's

SHAH & ANCHOR KUTCHHI ENGINEERING COLLEGE

Chembur, Mumbai - 400 088

UG Program in Electronics & Computer Science

void enqueue(int x) {
q[tail] = x;
tail++;
color[x] = B;
}

int dequeue() {
int x = q[head];
head++;
color[x] = C;
return x;
}

// Using BFS as a searching algorithm

int bfs(int start, int target) {
int u, v;
for (u = 0; u < n; u++) {
color[u] = A;
}
head = tail = 0;
enqueue(start);
pred[start] = -1;
while (head != tail) {
u = dequeue();
for (v = 0; v < n; v++) {
 Mahavir Education Trust's

SHAH & ANCHOR KUTCHHI ENGINEERING COLLEGE

Chembur, Mumbai - 400 088

UG Program in Electronics & Computer Science

if (color[v] == A && capacity[u][v] - flow[u][v] > 0) {

enqueue(v);
pred[v] = u;
}
}
}
return color[target] == C;
}

// Applying fordfulkerson algorithm

int fordFulkerson(int source, int sink) {
int i, j, u;
int max_flow = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
flow[i][j] = 0;
}
}

// Updating the residual values of edges

while (bfs(source, sink)) {
int increment = O;
for (u = n - 1; pred[u] >= 0; u = pred[u]) {
increment = min(increment, capacity[pred[u]][u] - flow[pred[u]][u]);
}
for (u = n - 1; pred[u] >= 0; u = pred[u]) {
 Mahavir Education Trust's

SHAH & ANCHOR KUTCHHI ENGINEERING COLLEGE

Chembur, Mumbai - 400 088

UG Program in Electronics & Computer Science

flow[pred[u]][u] += increment;
flow[u][pred[u]] -= increment;
}
// Adding the path flows
max_flow += increment;
}
return max_flow;
}

int main() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
capacity[i][j] = 0;
}
}
n = 6;
e = 7;

capacity[0][1] = 8;
capacity[0][4] = 3;
capacity[1][2] = 9;
capacity[2][4] = 7;
capacity[2][5] = 2;
capacity[3][5] = 5;
capacity[4][2] = 7;
capacity[4][3] = 4;
 Mahavir Education Trust's

SHAH & ANCHOR KUTCHHI ENGINEERING COLLEGE

Chembur, Mumbai - 400 088

UG Program in Electronics & Computer Science

int s = 0, t = 5;
printf("Max Flow: %d\n", fordFulkerson(s, t));
}

Input and Output:

 Mahavir Education Trust's

SHAH & ANCHOR KUTCHHI ENGINEERING COLLEGE

Chembur, Mumbai - 400 088

UG Program in Electronics & Computer Science

Conclusion:
In this experiment we have implemented Ford Fulkerson’s algorithm.