Ford Fulkerson Algorithm in C++

In this article, we will discuss the Ford Fulkerson Algorithm in C++ and its implementation.

What is the Ford Fulkerson Algorithm?

The Ford-Fulkerson algorithm is often used to solve maximum flow problems in flow. The maximum flow problem is concerned with finding the maximum amount of flow that can be transferred from the given source vertex to a sink vertex in a directionally weighted graph while considering edge capacity constraints. The technique operates by iteratively identifying an enhanced path in the residual graph, which connects the beginning point to the sink. It is the graph created by subtracting a current flow of data from the capacity of each edge. The program then increases the flow along this path by the maximum amount possible, which is equal to the minimum capacity of the path's edges.

Problem:

Consider a graph that depicts a flow network and each edge having the capacity value. Also, given two vertices in the network, source 's' and sink 't', determine the largest feasible flow from s to t with a few constraints:

Flow on an edge is limited to the edge's capacity.
Except for s and t, every vertex has the same incoming and outgoing flow.

The Ford-Fulkerson Algorithm

The following is a fundamental concept of the Ford-Fulkerson algorithm:

Begin with an initial flow of 0.
It also contains an additional passage from the source to the sink:
- Generate an expanded path using a path search technique such as: Breadth-first search or depth-first search.
- Calculate the flow rate that can be transferred along an extended path. This is the minimum remaining capacity at the end of the path.
- Increase the rate of flow along the augmenting path to the specified amount.
Return the highest possible flow.

Implementation:

First, let us explain the concept of Residual Graph, which is required to understand the implementation.

The residual graph of a flow network indicates more possible flows. If the residual graph has a path from source to sink, flow can be added. Every edge in a residual graph has an indicator called residual capacity, whose value is equal to the edge's initial capacity minus its present flow. Residual capacity refers to the edge's current capacity.

Now, let's go into the details of implementation. The residual capacity is zero if there is no edge between two vertices in the residual graph. We may initialize the residual graph as the initial graph because there is no starting flow, and the amount of residual capacity is equal to that of the original capacity at the start. We can perform a BFS or a DFS on the residual graph to discover an augmenting path. We can use BFS to determine whether or not a route exists from source to sink. BFS also generates a parent[] array. Using the parent[] array, we walk the discovered path to determine a feasible flow through it by calculating the minimal residual capacity along the path. After that, we include the discovered route flow into the overall flow.

The crucial point is that we update the residual capacity in the residual graph. We subtract route flow from all edges throughout the path and add it to the reverse edges. We need to provide route flow along reverse edges since we may need to send flow in the reverse direction.

Example:

Let us take an example to illustrate the Ford Fulkerson Algorithm in C++.

FileName: FordFulkerson.cpp

// Program to implement the the Ford-Fulkerson Algorithm 
#include <iostream>
#include <limits.h>
#include <queue>
#include <string.h>
using namespace std;

// Declaring the count of the vertices
#define V 6

/* Returns true if a path exists between source and sink 't' in the residual graph. Additionally, it stores the route in the parent[].*/
bool bfsSearch(int rGraph[V][V], int s, int t, int parent[])
{
	//The initial visited array, which is marked as not listed
	bool visited[V];
	memset(visited, 0, sizeof(visited));

	// Create a queue, enqueue the source vertex, and mark the source
	// vertex as visited
	queue<int> q;
	q.push(s);
	visited[s] = true;
	parent[s] = -1;

	//The logic for the BFS
	while (!q.empty()) {
		int u = q.front();
		q.pop();

		for (int v = 0; v < V; v++) {
			if (visited[v] == false && rGraph[u][v] > 0) {
				// checking for the condition in BFS for any node; we
				//If it is true, then the parent value is set to return true
				if (v == t) {
					parent[v] = u;
					return true;
				}
				q.push(v);
				parent[v] = u;
				visited[v] = true;
			}
		}
	}

	//As the sink node is not reached so, it will return as a false
	return false;
}

// the function for finding the flow in a graph
int fordFulkersonAlgo(int graph[V][V], int s, int t)
{
	int u, v;
     //Create an augmenting path using any path-finding
     // approach, including breadth-first or depth-first search.
    //Determine the quantity of flow that can be s
    //hared down the augmenting path, as well as the 
    //path?s edges' minimal residual capability.
	int rGraph[V]
			[V]; //the capacity of the residual graph
                                         // initialled with 0
				// from i to j (if there is an edge. If
				// rGraph[i][j] is 0, then there is no edge)
	for (u = 0; u < V; u++)
		for (v = 0; v < V; v++)
			rGraph[u][v] = graph[u][v];

	int parent[V]; // the bfs array for storing path
				// store path

	int max_flow = 0; //setting up the initial flow as 0
	//checking if the flow exists is not
	while (bfsSearch(rGraph, s, t, parent)) {
		//The minimum residual capacity can be found, and
		// the path filled by BFS.
                     //Or finding the maximum flow of the path
		int path_flow = INT_MAX;
		for (v = t; v != s; v = parent[v]) {
			u = parent[v];
			path_flow = min(path_flow, rGraph[u][v]);
		}

		//Update and reverse the edges 
		for (v = t; v != s; v = parent[v]) {
			u = parent[v];
			rGraph[u][v] -= path_flow;
			rGraph[v][u] += path_flow;
		}

		// adding up the flow path to the Toal flow
		max_flow += path_flow;
	}

	//The max flow is then returned
	return max_flow;
}

// Main section
int main()
{
	//The initial graph creation
	int graphS[V][V]
		= { { 0, 16, 13, 0, 12, 0 }, { 0, 0, 10, 22, 0, 0 },
			{ 0, 8, 0, 0, 14, 0 }, { 0, 0, 9, 0, 0, 20 },
			{ 0, 0, 0, 7, 0, 4 }, { 0, 0, 0, 1, 0, 0 } };

	cout << "The maximum possible flow is "
		<< fordFulkersonAlgo(graphS, 0, 5);

	return 0;
}

Output:

The maximum possible flow is 24

Complexity Analysis:

Time Complexity:

Time complexity is O(|V| * E^2), where E is the number of edges and V is the number of vertices.

Space complexity:

The space complexity is O(V) because we constructed a queue.

The above program used for the Ford Fulkerson Algorithm is referred to as the Edmonds-Karp Algorithm. Edmonds-Karp proposes using BFS in the Ford Fulkerson solution because BFS always chooses the path with the fewest number of edges. When using BFS, the worst-case time complexity is lowered to O(VE^2). The above implementation employs adjacency matrix accountability, however where BFS takes O(V^2) time, the above implementation requires O(EV^3).

Applications of Ford Fulkerson Algorithm:

The most popular technique for figuring out the maximum flow in a flow network is the Ford-Fulkerson algorithm. It has several uses in diverse fields. The Ford-Fulkerson method is commonly used in the following applications and scenarios:

Network:

Ford-Fulkerson algorithm is mostly used to solve network flow problems. It specifies the maximum quantity of flow that may be sent from a source to a sink in a flow network.

Transportation:

Optimizing transportation and logistics networks involves maximizing the flow of products from suppliers to the consumer through roads, trains, or other transportation linkages.

Telecommunication:

The technique can improve data flow in telecommunication networks, leading to effective communication between multiple nodes.

Image segmentation:

In artificial intelligence, the Ford-Fulkerson method may split images into segments depending on characteristics like intensity or color.

Next TopicTrie of all Suffixes in C++

← prev next →