Edge disjoint paths with Ford-Fulkerson algorithm

//
//  main.cpp
//  Edge Disjoint paths
//
//  Created by Longxiang Lyu on 8/15/16.
//  Copyright © 2016 Longxiang Lyu. All rights reserved.
//

#include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <algorithm>
#include <stack>

using namespace std;


bool bfs(vector<vector<int>> &rGraph, vector<int> &parent, int s, int t)
{
    int V = static_cast<int>(rGraph.size());
    vector<int> visited(V, 0);      // mark all vertices as unvisited
    queue<int> q;
    q.push(s);
    visited[s] = 1;                 // mark source vertex as visited
    
    parent.clear();
    parent.resize(V);
    parent[s] = -1;
    
    while (!q.empty())
    {
        int u = q.front();          // get the first element
        q.pop();
        
        for (int v = 0; v != V; ++v)
        {
            if (visited[v] == 0 && rGraph[u][v] > 0)
            {
                q.push(v);
                parent[v] = u;
                visited[v] = 1;
            }
        }
    }
    return visited[t] == 1;
}

void printM(const vector<vector<int>> &M)
{
    for (int i = 0; i != M.size(); ++i)
    {
        for (int j = 0; j != M[i].size(); ++j)
            cout << M[i][j] << " ";
        cout << endl;
    }
}

void buildPath(vector<vector<int>> &fGraph, vector<int> &path, int u, int dest)
{
    if (u == dest)
        return;
    int sz = static_cast<int>(fGraph[u].size());
    
    for (int j = 0; j != sz; ++j)
    {
        if (fGraph[u][j] > 0)
        {
            path.push_back(j);
            fGraph[u][j] = 0;
            buildPath(fGraph, path, j, dest);
            break;
        }
    }
    return;
}


int fordFulkerson(vector<vector<int>> &graph, vector<vector<int>> &paths, int s, int t)
{
    int u, v;
    
    
    vector<int> parent;
    
    auto rGraph = graph;
    
    int max_flow = 0;               // initially zero flow
    
    while (bfs(rGraph, parent, s, t))
    {
        int bottleneck = INT_MAX;
        
        // get the bottleneck capacity of the augment path
        for (v = t; v != s; v = parent[v])
        {
            u = parent[v];
            bottleneck = min(bottleneck, rGraph[u][v]);
        }
        
        for (v = t; v != s; v = parent[v])
        {
            u = parent[v];
            rGraph[u][v] -= bottleneck;
            rGraph[v][u] += bottleneck;
        }
        
        max_flow += bottleneck;
        
    }
    
    for (int i = 0; i != graph.size(); ++i)
    {
        for (int j = 0; j != graph.size(); ++j)
            graph[i][j] = graph[i][j] - rGraph[i][j] >= 0 ? graph[i][j] - rGraph[i][j] : 0;
    }
    
    paths.clear();
    paths.resize(max_flow);
    
    for (int i = 0; i != max_flow; ++i)
    {
        paths[i].push_back(s);
        buildPath(graph, paths[i], s, t);
    }
    
    return max_flow;
}




int main(int argc, const char * argv[])
{
    // insert code here...
    vector<vector<int>> graph = {
        {0, 1, 1, 1, 0, 0, 0, 0},
        {0, 0, 1, 0, 0, 0, 0, 0},
        {0, 0, 0, 1, 0, 0, 1, 0},
        {0, 0, 0, 0, 0, 0, 1, 0},
        {0, 0, 1, 0, 0, 0, 0, 1},
        {0, 1, 0, 0, 0, 0, 0, 1},
        {0, 0, 0, 0, 0, 1, 0, 1},
        {0, 0, 0, 0, 0, 0, 0, 0}
    };
    
    vector<vector<int>> paths;
    
    cout << "Number of edge disjoint paths: " << endl << fordFulkerson(graph, paths, 0, 7) << endl;
    
    for (auto a : paths)
    {
        for (auto b : a)
            cout << b << " ";
        cout << endl;
    }
    
    return 0;
}

reference:

http://www.cs.princeton.edu/~wayne/kleinberg-tardos/pdf/07NetworkFlowII-2x2.pdf

http://www.geeksforgeeks.org/find-edge-disjoint-paths-two-vertices/