Maximum Flow (Ford-Fulkerson) - Problem

Implement the Ford-Fulkerson algorithm to find the maximum flow in a flow network using BFS (Edmonds-Karp implementation).

Given a flow network represented as an adjacency matrix where capacity[u][v] represents the capacity of the edge from vertex u to vertex v, find the maximum flow from source s to sink t.

The Ford-Fulkerson method uses BFS to find augmenting paths and increases the flow along these paths until no more augmenting paths exist.

Key concepts:

Flow Network: A directed graph where each edge has a capacity
Augmenting Path: A path from source to sink with available capacity
Residual Graph: Graph showing remaining capacities after current flow
Max Flow Min Cut Theorem: Maximum flow equals minimum cut capacity

Input & Output

Example 1 — Basic Flow Network

$ Input: capacity = [[0,16,13,0,0,0],[0,0,0,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]], source = 0, sink = 5

› Output: 23

💡 Note: Maximum flow from vertex 0 to vertex 5 is 23. Path 0→1→3→5 gives flow 12, path 0→2→4→5 gives flow 4, path 0→2→4→3→5 gives flow 7.

Example 2 — Simple Network

$ Input: capacity = [[0,10,10,0],[0,0,0,10],[0,0,0,10],[0,0,0,0]], source = 0, sink = 3

› Output: 20

💡 Note: Two paths: 0→1→3 with flow 10 and 0→2→3 with flow 10. Total maximum flow is 20.

Example 3 — Bottleneck Network

$ Input: capacity = [[0,100,0,100],[0,0,1,0],[0,0,0,100],[0,0,0,0]], source = 0, sink = 3

› Output: 101

💡 Note: Direct path 0→3 gives flow 100, path 0→1→2→3 gives flow 1. Bottleneck at edge 1→2 limits this path.

Constraints

1 ≤ vertices ≤ 100
0 ≤ capacity[i][j] ≤ 1000
0 ≤ source, sink < vertices
source ≠ sink

Visualization

Tap to expand

Asked in

G Google 45 M Microsoft 38 a Amazon 32 f Facebook 28 N Netflix 22

The Ford-Fulkerson algorithm finds maximum flow by repeatedly finding augmenting paths from source to sink and pushing flow through them. The Edmonds-Karp implementation uses BFS to find shortest augmenting paths, ensuring polynomial time complexity. Key insight: maintain a residual graph with forward and backward edges to handle flow cancellation. Best approach is BFS (Edmonds-Karp) with Time: O(V × E²), Space: O(V²).

Common Approaches

✓ DFS All Paths

⏱️ Time: O(2^E) Space: O(V)

Use depth-first search to enumerate all possible paths from source to sink, calculate the bottleneck capacity for each path, and sum up the maximum possible flow. This approach is inefficient as it explores exponentially many paths.

Dinic's Algorithm

⏱️ Time: O(V² × E) Space: O(V²)

Dinic's algorithm improves on Ford-Fulkerson by using a level graph to guide path selection and blocking flows to push multiple augmenting paths simultaneously. This reduces the number of iterations needed to find maximum flow.

Ford-Fulkerson with BFS (Edmonds-Karp)

⏱️ Time: O(V × E²) Space: O(V²)

The classic Ford-Fulkerson algorithm using BFS (Edmonds-Karp implementation) to find shortest augmenting paths. Maintain a residual graph and repeatedly find paths from source to sink, pushing maximum flow through each path until no augmenting paths remain.

DFS All Paths — Algorithm Steps

DFS to find all paths from source to sink
For each path, find minimum capacity (bottleneck)
Sum up flows from non-overlapping paths
Return total maximum flow

Visualization

Tap to expand

Step-by-Step Walkthrough

DFS Exploration

Use DFS to find all paths from source to sink

Bottleneck Calculation

Find minimum capacity along each path

Flow Summation

Add up flows from all viable paths

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

int visited[100];

int dfs(int capacity[][100], int n, int u, int sink, int minCapacity) {
    if (u == sink) {
        return minCapacity;
    }
    
    visited[u] = 1;
    for (int v = 0; v < n; v++) {
        if (!visited[v] && capacity[u][v] > 0) {
            int newMin = (capacity[u][v] < minCapacity) ? capacity[u][v] : minCapacity;
            int flow = dfs(capacity, n, v, sink, newMin);
            if (flow > 0) {
                return flow;
            }
        }
    }
    visited[u] = 0;
    return 0;
}

int solution(int capacity[][100], int n, int source, int sink) {
    int maxFlow = 0;
    
    while (1) {
        memset(visited, 0, sizeof(visited));
        int flow = dfs(capacity, n, source, sink, INT_MAX);
        if (flow == 0) break;
        maxFlow += flow;
    }
    
    return maxFlow;
}

int main() {
    // Simplified input parsing
    int capacity[100][100];
    int n = 6; // Example size
    int source, sink;
    
    // Example capacity matrix
    memset(capacity, 0, sizeof(capacity));
    capacity[0][1] = 16; capacity[0][2] = 13;
    capacity[1][3] = 12; capacity[2][1] = 4; capacity[2][4] = 14;
    capacity[3][5] = 20; capacity[4][3] = 7; capacity[4][5] = 4;
    
    scanf("%d %d", &source, &sink);
    
    int result = solution(capacity, n, source, sink);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^E)

Exponential paths to explore in worst case

✓ Linear Growth

Space Complexity

O(V)

Recursion stack depth for DFS traversal

✓ Linear Space

75.0K Views

Medium Frequency

~35 min Avg. Time

1.9K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Maximum Flow (Ford-Fulkerson) - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

DFS All Paths — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler