#include <bits/stdc++.h>
using namespace std;
#define V 6
bool bfs(int rGraph[V][V], int s, int t, int parent[]){
	bool visited[V];
	memset(visited, 0, sizeof(visited));
	queue <int> q;
	q.push(s);
	visited[s] = true;
	parent[s] = -1;
	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;
			}
		}
	}
	return (visited[t] == true);
}

int fordFulkerson(int graph[V][V], int s, int t){
	int u, v;
	int rGraph[V][V]; // Residual graph where rGraph[i][j] indicates
					// residual capacity of edge from i to j (if there
					// is an edge. If rGraph[i][j] is 0, then there is not)
	for (u = 0; u < V; u++)
		for (v = 0; v < V; v++)
			rGraph[u][v] = graph[u][v];
	int parent[V];
	int max_flow = 0; // There is no flow initially
	while (bfs(rGraph, s, t, parent)){
		int path_flow = INT_MAX;
		for (v=t; v!=s; v=parent[v]){
			u = parent[v];
			path_flow = min(path_flow, rGraph[u][v]);
		}
		for (v=t; v != s; v=parent[v]){
			u = parent[v];
			rGraph[u][v] -= path_flow;
			rGraph[v][u] += path_flow;
		}
		max_flow += path_flow;
	}
	return max_flow;
}

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}
					};
  int origen = 0;
  int dest = 5;
	cout << "The maximum possible flow is "
       << fordFulkerson(graph, origen, dest);

	return 0;
}

Add Ford Fulkerson algorithm to find the max flow.
Add Ford Fulkerson algorithm to find the max flow.
