EdmondsKarp algorithm added.

Author: Sivasuthan9

src/main/java/com/thealgorithms/graph/BronKerbosch.java

@@ -13,7 +13,7 @@
  * set of vertices adjacent to {@code u}. The algorithm runs in time proportional to the number of
  * maximal cliques produced and is widely used for clique enumeration problems.</p>
  *
- * @author <a href="https://github.com/VictorFrench">Victor French</a>
+ * @author <a href="https://en.wikipedia.org/wiki/Bron%E2%80%93Kerbosch_algorithm">Wikipedia: Bron–Kerbosch algorithm</a>
  */
 public final class BronKerbosch {
 

src/main/java/com/thealgorithms/graph/EdmondsKarp.java

@@ -0,0 +1,107 @@
+package com.thealgorithms.graph;
+
+import java.util.ArrayDeque;
+import java.util.Arrays;
+import java.util.Queue;
+
+/**
+ * Implementation of the Edmonds–Karp algorithm for computing the maximum flow of a directed graph.
+ * <p>
+ * The algorithm runs in O(V * E^2) time and is a specific implementation of the Ford–Fulkerson
+ * method where the augmenting paths are found using breadth-first search (BFS) to ensure the
+ * shortest augmenting paths (in terms of the number of edges) are used.
+ * </p>
+ *
+ * <p>The graph is represented with a capacity matrix where {@code capacity[u][v]} denotes the
+ * capacity of the edge from {@code u} to {@code v}. Negative capacities are not allowed.</p>
+ *
+ * @author <a href="https://en.wikipedia.org/wiki/Edmonds%E2%80%93Karp_algorithm">Wikipedia: EdmondsKarp algorithm</a>
+ */
+public final class EdmondsKarp {
+
+    private EdmondsKarp() {
+    }
+
+    /**
+     * Computes the maximum flow from {@code source} to {@code sink} in the provided capacity matrix.
+     *
+     * @param capacity the capacity matrix representing the directed graph; must be square and non-null
+     * @param source the source vertex index
+     * @param sink the sink vertex index
+     * @return the value of the maximum flow between {@code source} and {@code sink}
+     * @throws IllegalArgumentException if the matrix is {@code null}, not square, contains negative
+     *         capacities, or if {@code source} / {@code sink} indices are invalid
+     */
+    public static int maxFlow(int[][] capacity, int source, int sink) {
+        if (capacity == null || capacity.length == 0) {
+            throw new IllegalArgumentException("Capacity matrix must not be null or empty");
+        }
+
+        final int n = capacity.length;
+        for (int row = 0; row < n; row++) {
+            if (capacity[row] == null || capacity[row].length != n) {
+                throw new IllegalArgumentException("Capacity matrix must be square");
+            }
+            for (int col = 0; col < n; col++) {
+                if (capacity[row][col] < 0) {
+                    throw new IllegalArgumentException("Capacities must be non-negative");
+                }
+            }
+        }
+
+        if (source < 0 || source >= n || sink < 0 || sink >= n) {
+            throw new IllegalArgumentException("Source and sink must be valid vertex indices");
+        }
+        if (source == sink) {
+            return 0;
+        }
+
+        final int[][] residual = new int[n][n];
+        for (int i = 0; i < n; i++) {
+            residual[i] = Arrays.copyOf(capacity[i], n);
+        }
+
+        final int[] parent = new int[n];
+        int maxFlow = 0;
+
+        while (bfs(residual, source, sink, parent)) {
+            int pathFlow = Integer.MAX_VALUE;
+            for (int v = sink; v != source; v = parent[v]) {
+                int u = parent[v];
+                pathFlow = Math.min(pathFlow, residual[u][v]);
+            }
+
+            for (int v = sink; v != source; v = parent[v]) {
+                int u = parent[v];
+                residual[u][v] -= pathFlow;
+                residual[v][u] += pathFlow;
+            }
+
+            maxFlow += pathFlow;
+        }
+
+        return maxFlow;
+    }
+
+    private static boolean bfs(int[][] residual, int source, int sink, int[] parent) {
+        Arrays.fill(parent, -1);
+        parent[source] = source;
+
+        Queue<Integer> queue = new ArrayDeque<>();
+        queue.add(source);
+
+        while (!queue.isEmpty()) {
+            int u = queue.poll();
+            for (int v = 0; v < residual.length; v++) {
+                if (residual[u][v] > 0 && parent[v] == -1) {
+                    parent[v] = u;
+                    if (v == sink) {
+                        return true;
+                    }
+                    queue.add(v);
+                }
+            }
+        }
+        return false;
+    }
+}

src/test/java/com/thealgorithms/graph/EdmondsKarpTest.java

@@ -0,0 +1,67 @@
+package com.thealgorithms.graph;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class EdmondsKarpTest {
+
+    @Test
+    @DisplayName("Classic CLRS network yields max flow 23")
+    void clrsExample() {
+        int[][] capacity = {
+            {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 maxFlow = EdmondsKarp.maxFlow(capacity, 0, 5);
+        assertEquals(23, maxFlow);
+    }
+
+    @Test
+    @DisplayName("Disconnected network has zero flow")
+    void disconnectedGraph() {
+        int[][] capacity = {
+            {0, 0, 0},
+            {0, 0, 0},
+            {0, 0, 0}
+        };
+        int maxFlow = EdmondsKarp.maxFlow(capacity, 0, 2);
+        assertEquals(0, maxFlow);
+    }
+
+    @Test
+    @DisplayName("Source equals sink returns zero")
+    void sourceEqualsSink() {
+        int[][] capacity = {
+            {0, 5},
+            {0, 0}
+        };
+        int maxFlow = EdmondsKarp.maxFlow(capacity, 0, 0);
+        assertEquals(0, maxFlow);
+    }
+
+    @Test
+    @DisplayName("Invalid matrix throws exception")
+    void invalidMatrix() {
+        int[][] capacity = {
+            {0, 1},
+            {1}
+        };
+        assertThrows(IllegalArgumentException.class, () -> EdmondsKarp.maxFlow(capacity, 0, 1));
+    }
+
+    @Test
+    @DisplayName("Negative capacity is rejected")
+    void negativeCapacity() {
+        int[][] capacity = {
+            {0, -1},
+            {0, 0}
+        };
+        assertThrows(IllegalArgumentException.class, () -> EdmondsKarp.maxFlow(capacity, 0, 1));
+    }
+}