Ford-Fulkerson Maximum Flow: Complete Implementation Guide

Introduction and Core Concepts

The Ford-Fulkerson maximum flow algorithm is one of the most fundamental and elegant algorithms in graph theory, providing a systematic method to compute the maximum possible flow from a source node to a sink node in a flow network. First published in 1956 by L. R. Ford Jr. and D. R. Fulkerson, this algorithm forms the backbone of network flow theory and underpins countless optimization problems in computer science, operations research, and engineering. Understanding ford-fulkerson maximum flow is essential for any developer or engineer working with networks, resource allocation, or connectivity problems.

At its core, a flow network is a directed graph where each edge has a capacity that limits the amount of flow that can pass through it. The network has two distinguished vertices: the source (s), where flow originates, and the sink (t), where flow terminates. The objective is to push as much flow as possible from s to t without exceeding edge capacities and while respecting flow conservation at every intermediate vertex — meaning inflow must equal outflow for all nodes except s and t. This abstract model is remarkably versatile and captures the essence of many real systems.

The Ford-Fulkerson method is not a single rigid algorithm but rather a framework or meta-algorithm that can be implemented in different ways depending on how augmenting paths are found. The key insight is the concept of the residual graph, which represents the remaining capacity for additional flow. For every edge (u, v) with capacity c and flow f, the residual graph contains a forward edge with residual capacity c - f and a backward edge with capacity f, allowing the algorithm to "undo" previously made flow decisions. This ability to backtrack is what guarantees optimality and distinguishes it from greedy approaches.

Why does this matter? Maximum flow problems appear everywhere: determining the maximum throughput of a computer network, optimizing traffic in transportation systems, matching jobs to applicants, segmenting images in computer vision, and even eliminating baseball teams from playoff contention. The max-flow min-cut theorem, which Ford-Fulkerson proves constructively, states that the maximum flow value equals the capacity of the minimum cut — the smallest set of edges whose removal disconnects s from t. This duality provides both a certificate of optimality and deep theoretical insight into network bottlenecks.

How It Works

The Ford-Fulkerson method operates on a simple iterative principle: while there exists an augmenting path from source to sink in the residual graph, push additional flow along that path. An augmenting path is any directed path from s to t where every edge has positive residual capacity. The amount of flow that can be pushed is limited by the bottleneck capacity — the minimum residual capacity along the path. After augmenting, the residual graph is updated to reflect the new flow, and the process repeats until no augmenting path remains.

The residual graph is the central data structure that makes the algorithm work. Initially, the residual graph is identical to the original graph, with flow 0 everywhere. When we push f units of flow along a path, we decrease the residual capacity of each forward edge on the path by f and increase the residual capacity of each reverse edge by f. The reverse edges are crucial; they do not exist in the original network but represent the ability to cancel flow. For example, if we previously sent 10 units from A to B, the residual graph will have a reverse edge B -> A with capacity 10, allowing a future augmenting path to route flow back and redirect it through a more efficient route.

This mechanism can be understood through three key phases executed in a loop. First, path discovery: use graph traversal (Depth-First Search or Breadth-First Search) to find any s-t path with available capacity. Second, bottleneck computation: traverse the discovered path to find its minimum residual capacity. Third, augmentation and update: add the bottleneck value to the total flow and update residual capacities along the path. The algorithm terminates when the traversal fails to reach the sink, which by the max-flow min-cut theorem proves that the current flow is maximal.

The Max-Flow Min-Cut Theorem

The theoretical foundation of Ford-Fulkerson is the max-flow min-cut theorem. A cut (S, T) partitions vertices into two sets where s is in S and t is in T. Its capacity is the sum of capacities of edges going from S to T. The theorem states that the value of the maximum flow equals the capacity of the minimum cut. When Ford-Fulkerson terminates, the set of vertices reachable from s in the final residual graph defines a minimum cut, and no augmenting path exists precisely because this cut is saturated. This provides a powerful way to not only compute the flow value but also identify the network's bottleneck edges.

Augmenting Paths and Residual Capacity

Consider a simple network: s -> A (capacity 10), s -> B (capacity 10), A -> t (capacity 10), B -> t (capacity 10), and A -> B (capacity 1). A naive greedy algorithm might saturate s -> A -> B -> t first, blocking optimal flow. Ford-Fulkerson avoids this trap via residual edges. After that suboptimal path is chosen, the residual graph contains B -> A with capacity 1, enabling a later augmenting path s -> B -> A -> t to cancel the misrouted unit and achieve the true maximum flow of 20. This illustrates why residual graphs are more powerful than simply tracking used capacity.

Implementation

Implementing Ford-Fulkerson requires careful management of the residual graph, typically represented as an adjacency matrix or adjacency list with capacity values. The choice of path-finding strategy determines both correctness and performance. The simplest variant uses Depth-First Search (DFS), while the Edmonds-Karp variant uses Breadth-First Search (BFS) to guarantee polynomial time. Below are production-ready Python implementations with detailed comments.

The first implementation shows the classic DFS-based Ford-Fulkerson using an adjacency matrix. It is intuitive and works well for integer capacities but can be slow with poor path choices. Note how we maintain a parent array to reconstruct the path and use recursion or an explicit stack for DFS.

from collections import deque
import sys

def bfs_find_path(residual, source, sink, parent):
    """BFS to find augmenting path. Returns True if path exists."""
    visited = [False] * len(residual)
    queue = deque([source])
    visited[source] = True
    
    while queue:
        u = queue.popleft()
        for v, capacity in enumerate(residual[u]):
            if not visited[v] and capacity > 0:
                queue.append(v)
                visited[v] = True
                parent[v] = u
                if v == sink:
                    return True
    return False

def ford_fulkerson_bfs(graph, source, sink):
    """
    Edmonds-Karp implementation (Ford-Fulkerson with BFS).
    graph: adjacency matrix where graph[u][v] = capacity
    Returns max flow value.
    """
    n = len(graph)
    # Create residual graph - deep copy
    residual = [row[:] for row in graph]
    parent = [-1] * n
    max_flow = 0

    # Augment while path exists
    while bfs_find_path(residual, source, sink, parent):
        # Find bottleneck (minimum residual capacity on path)
        path_flow = float('inf')
        s = sink
        while s != source:
            path_flow = min(path_flow, residual[parent[s]][s])
            s = parent[s]
        
        # Update residual capacities
        v = sink
        while v != source:
            u = parent[v]
            residual[u][v] -= path_flow
            residual[v][u] += path_flow  # reverse edge
            v = parent[v]
        
        max_flow += path_flow
    
    return max_flow

# Example usage
if __name__ == "__main__":
    # Graph with 6 nodes (0=source, 5=sink)
    graph = [
        [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]
    ]
    print(f"Max Flow: {ford_fulkerson_bfs(graph, 0, 5)}")  # Expected 23

The second implementation uses an adjacency list, which is far more memory-efficient for sparse graphs — the common case in real networks. It encapsulates logic in a class and supports adding edges with automatic reverse edge creation, a pattern used in competitive programming and production systems.

from collections import deque, defaultdict

class FlowNetwork:
    def __init__(self, vertices):
        self.V = vertices
        self.graph = defaultdict(dict)  # adj list: u -> {v: capacity}

    def add_edge(self, u, v, capacity):
        """Add edge with capacity. Handles parallel edges by summing."""
        if v in self.graph[u]:
            self.graph[u][v] += capacity
        else:
            self.graph[u][v] = capacity
        # Ensure reverse edge exists with 0 capacity
        if u not in self.graph[v]:
            self.graph[v][u] = 0

    def bfs(self, s, t, parent):
        visited = [False] * self.V
        queue = deque([s])
        visited[s] = True
        parent[s] = -1

        while queue:
            u = queue.popleft()
            for v, cap in self.graph[u].items():
                if not visited[v] and cap > 0:
                    visited[v] = True
                    parent[v] = u
                    queue.append(v)
                    if v == t:
                        return True
        return False

    def max_flow(self, source, sink):
        parent = [-1] * self.V
        max_flow = 0

        while self.bfs(source, sink, parent):
            path_flow = float('inf')
            s = sink
            while s != source:
                path_flow = min(path_flow, self.graph[parent[s]][s])
                s = parent[s]

            max_flow += path_flow
            v = sink
            while v != source:
                u = parent[v]
                self.graph[u][v] -= path_flow
                self.graph[v][u] += path_flow
                v = parent[v]

        return max_flow

For cases where recursion depth is a concern or you need explicit DFS control, the following iterative DFS version demonstrates the original Ford-Fulkerson approach. While not polynomial in the worst case, it is often faster in practice for certain graph structures and is useful for educational purposes.

def dfs_find_path(residual, u, sink, visited, parent):
    """Recursive DFS to find augmenting path."""
    visited[u] = True
    if u == sink:
        return True
    for v in range(len(residual)):
        if not visited[v] and residual[u][v] > 0:
            parent[v] = u
            if dfs_find_path(residual, v, sink, visited, parent):
                return True
    return False

def ford_fulkerson_dfs(graph, source, sink):
    """Ford-Fulkerson with DFS - may be exponential but simple."""
    n = len(graph)
    residual = [row[:] for row in graph]
    max_flow = 0
    parent = [-1] * n

    visited = [False] * n
    while dfs_find_path(residual, source, sink, visited, parent):
        path_flow = float('inf')
        s = sink
        while s != source:
            path_flow = min(path_flow, residual[parent[s]][s])
            s = parent[s]

        v = sink
        while v != source:
            u = parent[v]
            residual[u][v] -= path_flow
            residual[v][u] += path_flow
            v = parent[v]

        max_flow += path_flow
        visited = [False] * n
        parent = [-1] * n

    return max_flow

A more advanced implementation handles large graphs with capacity scaling, which dramatically improves performance when capacities vary widely. This technique processes edges in decreasing order of capacity significance.

def max_flow_capacity_scaling(graph, source, sink):
    """
    Capacity scaling variant - O(E^2 log U) where U is max capacity.
    Efficient when capacities are large.
    """
    n = len(graph)
    residual = [row[:] for row in graph]
    max_cap = max(max(row) for row in graph)
    
    # Find initial delta = largest power of 2 <= max_cap
    delta = 1
    while delta <= max_cap:
        delta <<= 1
    delta >>= 1

    max_flow = 0
    parent = [-1] * n

    def bfs_with_delta(delta_val):
        visited = [False] * n
        queue = deque([source])
        visited[source] = True
        parent[source] = -1
        while queue:
            u = queue.popleft()
            for v in range(n):
                if not visited[v] and residual[u][v] >= delta_val:
                    visited[v] = True
                    parent[v] = u
                    queue.append(v)
                    if v == sink:
                        return True
        return False

    while delta >= 1:
        while bfs_with_delta(delta):
            path_flow = float('inf')
            s = sink
            while s != source:
                path_flow = min(path_flow, residual[parent[s]][s])
                s = parent[s]
            v = sink
            while v != source:
                u = parent[v]
                residual[u][v] -= path_flow
                residual[v][u] += path_flow
                v = parent[v]
            max_flow += path_flow
        delta >>= 1

    return max_flow

Step-by-Step Example

To solidify understanding, let's walk through a concrete example with six vertices. Consider the classic flow network often used in textbooks: vertices 0 (source) through 5 (sink) with the following capacities: 0->1:16, 0->2:13, 1->2:10, 1->3:12, 2->1:4, 2->4:14, 3->2:9, 3->5:20, 4->3:7, 4->5:4. The goal is to compute the maximum flow from 0 to 5.

Initialization: max_flow = 0, residual graph = original graph. Iteration 1: BFS finds path 0->1->3->5. Bottleneck is min(16, 12, 20) = 12. Augment 12 units. Residual updates: 0->1 becomes 4, 1->3 becomes 0, 3->5 becomes 8, and reverse edges 1->0:12, 3->1:12, 5->3:12 are created. Total flow = 12.

Iteration 2: BFS finds path 0->2->4->5. Bottleneck is min(13, 14, 4) = 4. Augment 4 units. Residual: 0->2 becomes 9, 2->4 becomes 10, 4->5 becomes 0. Total flow = 16. Iteration 3: BFS finds path 0->2->4->3->5. Note that 4->3 has capacity 7, and 3->5 now has 8. Bottleneck is min(9, 10, 7, 8) = 7. Augment 7 units. Residual: 0->2 becomes 2, 2->4 becomes 3, 4->3 becomes 0, 3->5 becomes 1. Total flow = 23.

Iteration 4: BFS attempts to find another path. Possible candidates like 0->1->2->4->3->5 fail because 1->3 is saturated and 4->5 is saturated. The only remaining forward edges from source are 0->1 (4) and 0->2 (2), but neither can reach the sink due to saturated cuts. BFS from source visits {0,1,2,4} but cannot reach 5. No augmenting path exists, so the algorithm terminates with max_flow = 23. The reachable set {0,1,2,4} defines the minimum cut with capacity 23 (edges 1->3:12, 4->3:7, 4->5:4 sum to 23), confirming optimality.

Visualizing Residual Updates

After each augmentation, the residual graph evolves. After iteration 1, the edge 1->3 disappears from the residual graph (capacity 0) but reverse edge 3->1 appears. This allows future paths to use 3->1 to reroute flow if needed. After iteration 3, the path uses 4->3, which was originally a forward edge but now becomes saturated, while its reverse 3->4 gains capacity 7. Tracking these updates manually is tedious, which is why programmatic implementation with adjacency matrices or lists is preferred for verification.

Complexity Analysis

Complexity analysis of Ford-Fulkerson is nuanced because its running time depends heavily on the path selection strategy and the nature of capacities. The generic Ford-Fulkerson method with DFS does not guarantee polynomial time; its complexity is pseudo-polynomial, bounded by the value of the maximum flow itself.

For the DFS-based variant, each augmentation increases flow by at least 1 (assuming integer capacities), so there can be up to |f*| augmentations where |f*| is the max flow value. Each DFS takes O(E) time, leading to O(E * |f*|) time complexity. If capacities are large (e.g., 10^9), this can be extremely slow, and with irrational capacities, the algorithm may not even terminate. Space complexity is O(V^2) for adjacency matrix or O(V + E) for adjacency list.

The Edmonds-Karp variant, which uses BFS to always choose the shortest augmenting path (fewest edges), guarantees polynomial time: O(V * E^2). The proof relies on the fact that the distance from source to any vertex in the residual graph never decreases, and each edge can become critical (bottleneck) at most O(V) times. Capacity scaling improves this to O(E^2 log U) where U is the maximum capacity, while Dinic's algorithm further improves to O(V^2 * E) generally and O(min(V^(2/3), sqrt(E)) * E) for unit networks.

In practice, Edmonds-Karp is sufficient for graphs with up to a few thousand vertices and edges. For larger networks or those with huge capacities, Dinic's algorithm or Push-Relabel (O(V^3)) is preferred. The key takeaway is to never use naive DFS Ford-Fulkerson with large integer capacities in production; always prefer BFS or scaling variants to avoid exponential blowup.

Variations and Optimizations

Several important variations build upon the Ford-Fulkerson framework to improve efficiency, handle special cases, or extend functionality. Understanding these helps select the right tool for a given problem constraint.

Edmonds-Karp is the most common optimization, simply replacing DFS with BFS. This small change guarantees polynomial time and is often the default implementation taught in universities. It finds the shortest augmenting path in terms of number of edges, which not only bounds the number of augmentations to O(V*E) but also tends to find larger bottleneck capacities earlier in practice.

Capacity Scaling addresses the weakness of Edmonds-Karp when capacities are large and vary widely. It introduces a scaling parameter Δ, initially the largest power of two ≤ U. The algorithm only considers edges with residual capacity ≥ Δ, augmenting along paths that can carry at least Δ flow. When no such path exists, Δ is halved. This ensures that each augmentation carries significant flow, reducing the number of augmentations to O(E log U). It is particularly effective for networks where max capacity is orders of magnitude larger than min capacity.

Dinic's Algorithm is a more sophisticated improvement that builds a level graph using BFS and then finds blocking flows using DFS. It runs in O(V^2 * E) worst-case but is much faster in practice, especially for bipartite matching and unit capacity networks where it achieves near-linear time. Dinic's combines BFS layering with DFS augmentation, making it the go-to for competitive programming.

Other notable variants include the Push-Relabel algorithm (also called preflow-push), which does not maintain a feasible flow during execution but instead pushes excess flow and relabels vertices based on height, achieving O(V^3) or O(V^2 * sqrt(E)) with heuristics. For networks with irrational capacities, the Edmonds-Karp variant is required for termination, as generic DFS may loop infinitely. Additionally, extensions handle multiple sources/sinks by adding a super-source and super-sink, and handle vertex capacities by splitting vertices into in/out nodes.

Real-World Applications

Maximum flow is not just an academic exercise; it models a vast range of real-world optimization problems across industries. The ability to compute bottlenecks and optimal throughput makes it indispensable in network design and resource allocation.

In computer networks and web infrastructure, Ford-Fulkerson determines the maximum data throughput between servers, helps in load balancing across multiple paths, and identifies critical links whose failure would most degrade performance. Content Delivery Networks (CDNs) use max flow to route user requests to edge servers while respecting bandwidth constraints. Similarly, in telecommunications, it optimizes routing of calls or packets through switches with limited capacity.

In transportation and logistics, the algorithm optimizes the flow of goods from factories to warehouses to customers, airline scheduling, and traffic flow in road networks. For example, a city can model intersections as vertices and roads as edges with capacities (vehicles per hour) to find the maximum evacuation rate or to identify where to add lanes to relieve congestion. Airlines use it to maximize passenger flow through hub-and-spoke networks under seat capacity constraints.

Bipartite matching, a special case of max flow, powers job assignment, ad allocation, and recommendation systems. By creating a source connected to all applicants, edges from applicants to jobs they qualify for (capacity 1), and jobs to sink, the max flow equals the maximum matching. This is used in dating apps, university admissions, and assigning tasks to workers in crowdsourcing platforms. Databases use similar techniques for query optimization and resource allocation in distributed systems.

Other surprising applications include image segmentation in computer vision (using min-cut to separate foreground/background), baseball elimination (determining if a team can still finish first), project selection with dependencies (max closure problem), and network reliability analysis. In distributed databases, max flow helps allocate replicas to minimize replication cost while meeting availability constraints. Even in web servers, connection pooling and request throttling can be modeled as flow problems to prevent overload.

Comparison with Alternatives

While Ford-Fulkerson is foundational, several alternative maximum flow algorithms offer different trade-offs in complexity, implementation effort, and performance. Choosing the right one depends on graph size, density, capacity characteristics, and whether you need exact or approximate solutions.

Dinic's algorithm is generally considered superior to Edmonds-Karp for most practical purposes, especially for large graphs. It uses BFS to build a level graph and then sends multiple augmenting flows in one DFS phase, reducing the number of BFS iterations. Push-Relabel algorithms take a different approach entirely, maintaining a preflow where vertices can have excess flow and pushing it downhill based on height labels. They are often the fastest in practice for dense graphs but are more complex to implement correctly.

For specialized cases, even simpler algorithms exist. For bipartite matching with unit capacities, Hopcroft-Karp (O(E * sqrt(V))) is faster than generic max flow. For undirected graphs, the Stoer-Wagner algorithm finds min-cut without max flow. When only approximate max flow is needed, recent almost-linear time algorithms using electrical flows can be used, but they are highly complex and rarely implemented outside research.

The key distinction is that Ford-Fulkerson (DFS) is easy to implement but not polynomial, Edmonds-Karp is polynomial and simple, Dinic's is polynomial and fast, and Push-Relabel is polynomial and often fastest but complex. For interview settings, Edmonds-Karp is usually expected; for production with large graphs, Dinic's or Push-Relabel is preferred.

Common Mistakes and Best Practices

Implementing Ford-Fulkerson correctly requires attention to several subtle pitfalls that can lead to incorrect results, infinite loops, or poor performance. Awareness of these issues separates a working implementation from a robust one.

A frequent mistake is forgetting to add reverse edges in the residual graph or incorrectly updating them. Every augmentation must both decrease forward residual capacity and increase reverse capacity by the same amount. Omitting the reverse update prevents the algorithm from undoing bad decisions and can yield suboptimal flow. Another error is using an adjacency matrix for sparse graphs, wasting O(V^2) memory when O(V+E) would suffice. For graphs with thousands of vertices but few edges, an adjacency list with dictionary or list of edge objects is essential.

Another common pitfall is not handling parallel edges correctly. If the input contains multiple edges between the same vertices, capacities should be summed or edges stored separately. Also, using recursion for DFS without increasing recursion limit can cause stack overflow on large graphs; iterative BFS/DFS is safer. With DFS Ford-Fulkerson, developers often assume it will be fast enough, but with capacities like 1,000,000, the algorithm may require a million augmentations of 1 unit each, leading to timeouts. Always prefer Edmonds-Karp or capacity scaling for large capacities.

Best practices include: always use BFS (Edmonds-Karp) unless you have a specific reason not to; use 0-indexed vertices consistently; validate that source != sink and capacities are non-negative; use long integers (Python int is unbounded, but in other languages use 64-bit) to avoid overflow when summing flows; and test on known examples including graphs with cycles, disconnected components, and zero-capacity edges. For production code, encapsulate the graph in a class with methods add_edge, max_flow, and min_cut extraction. Finally, remember to reset visited arrays correctly between BFS iterations and to reconstruct paths using parent pointers rather than storing full paths.

Debugging Checklist

• Verify residual graph initialization is a deep copy, not a reference.
• Ensure BFS/DFS only traverses edges with residual capacity > 0.
• Check that bottleneck calculation uses min along the entire path, not just first edge.
• Confirm total flow is incremented by bottleneck, not by 1.
• Test with the classic 6-node example (expected flow 23) and simple cases like single edge, no path, and parallel paths.

Interview Questions

Ford-Fulkerson and maximum flow are frequent topics in technical interviews for software engineering, especially for roles involving networks, optimization, or algorithm design. Below are common questions with concise answers to help you prepare.

Q1: Explain the difference between Ford-Fulkerson and Edmonds-Karp. Why does Edmonds-Karp guarantee polynomial time?

Ford-Fulkerson is a general method that repeatedly finds any augmenting path, while Edmonds-Karp is a specific implementation that uses BFS to find the shortest augmenting path (fewest edges). Generic Ford-Fulkerson with DFS can take O(E * |f*|) time, which is pseudo-polynomial and can be exponential in input size if capacities are large, and may not terminate with irrational capacities. Edmonds-Karp guarantees O(V * E^2) because each BFS is O(E) and the number of augmentations is bounded by O(V*E) — each edge can become critical at most O(V) times and distances from source never decrease. This makes it polynomial regardless of capacity values.

Q2: How would you find the minimum cut after computing maximum flow?

After max flow is computed, run BFS/DFS from the source in the final residual graph, traversing only edges with residual capacity > 0. The set S of reachable vertices and T = V \ S defines the minimum cut. The cut capacity equals the max flow value, and the edges crossing from S to T in the original graph are the bottleneck edges. Implementation-wise, reuse the same BFS used for augmenting path search but collect all visited nodes instead of stopping at sink. This is useful for network reliability and image segmentation problems.

Q3: How do you handle multiple sources and sinks, or vertex capacities?

For multiple sources/sinks, create a super-source connected to all original sources with infinite capacity, and a super-sink connected from all original sinks with infinite capacity, then run max flow from super-source to super-sink. For vertex capacities (limit on flow through a vertex), split each vertex v into v_in and v_out with an edge v_in -> v_out having capacity equal to the vertex capacity. All incoming edges go to v_in, all outgoing edges leave from v_out. This transforms vertex constraints into edge constraints without changing the algorithm.

Q4: What is the time complexity of Ford-Fulkerson and when would you prefer Dinic's algorithm?

Naive DFS Ford-Fulkerson is O(E * |f*|) pseudo-polynomial; Edmonds-Karp is O(V * E^2). Dinic's is O(V^2 * E) worst-case but much faster in practice, especially for unit capacities or bipartite matching where it is O(min(V^(2/3), sqrt(E)) * E). Prefer Dinic's when graphs are large (V > 1000, E > 10000), dense, or when you need to run max flow many times. For interviews, Edmonds-Karp is usually sufficient and simpler to code correctly under time pressure.

Q5: Can Ford-Fulkerson handle irrational capacities? What happens?

The generic DFS Ford-Fulkerson may not terminate with irrational capacities — there exists a constructed example where it loops infinitely, converging to a value less than the true max flow. Edmonds-Karp (BFS) and other polynomial variants do terminate even with irrational capacities because they bound the number of augmentations independently of capacity values. In practice, capacities are almost always integers or rationals, so this is rarely an issue, but it highlights why BFS is theoretically more robust.

Mastering these concepts and being able to code Edmonds-Karp from memory in under 20 minutes is a strong signal in interviews. Practice implementing both matrix and adjacency list versions, and be ready to adapt the template to bipartite matching or min-cut problems.