feat(js): add modular solution and documentation for hard challenge 2 - Maximum Flow (Edmonds-Karp Algorithm)

Author: IbatoLionDev

3-HARD/JavaScript/2-maximum-flow-edmonds-karp/README.md

@@ -0,0 +1,131 @@
+# Maximum Flow - Edmonds-Karp Algorithm
+
+## English
+
+The Maximum Flow problem involves finding the greatest possible flow in a flow network from a source node to a sink node without violating capacity constraints on the edges.
+
+This challenge requires implementing the Edmonds-Karp algorithm, which is an implementation of the Ford-Fulkerson method using BFS to find augmenting paths. The solution is implemented in JavaScript using Object-Oriented Programming (OOP) principles and follows DRY (Don't Repeat Yourself) best practices.
+
+### Relevant Code Snippet
+
+```javascript
+class MaximumFlow {
+  constructor(graph) {
+    this.graph = graph;
+    this.n = graph.length;
+  }
+
+  bfs(source, sink, parent) {
+    const visited = new Array(this.n).fill(false);
+    const queue = [];
+    queue.push(source);
+    visited[source] = true;
+    parent[source] = -1;
+
+    while (queue.length > 0) {
+      const u = queue.shift();
+
+      for (let v = 0; v < this.n; v++) {
+        if (!visited[v] && this.graph[u][v] > 0) {
+          queue.push(v);
+          parent[v] = u;
+          visited[v] = true;
+        }
+      }
+    }
+    return visited[sink];
+  }
+
+  edmondsKarp(source, sink) {
+    const parent = new Array(this.n);
+    let maxFlow = 0;
+
+    while (this.bfs(source, sink, parent)) {
+      let pathFlow = Infinity;
+      for (let v = sink; v !== source; v = parent[v]) {
+        const u = parent[v];
+        pathFlow = Math.min(pathFlow, this.graph[u][v]);
+      }
+
+      for (let v = sink; v !== source; v = parent[v]) {
+        const u = parent[v];
+        this.graph[u][v] -= pathFlow;
+        this.graph[v][u] += pathFlow;
+      }
+
+      maxFlow += pathFlow;
+    }
+    return maxFlow;
+  }
+}
+```
+
+### History
+
+The Maximum Flow problem and the Edmonds-Karp algorithm have been fundamental in network flow theory since the 1950s. The Edmonds-Karp algorithm improves the Ford-Fulkerson method by using BFS to find shortest augmenting paths, ensuring polynomial time complexity.
+
+---
+
+## Español
+
+El problema de Flujo Máximo consiste en encontrar el flujo máximo posible en una red de flujo desde un nodo fuente hasta un nodo sumidero sin violar las capacidades de las aristas.
+
+Este reto requiere implementar el algoritmo de Edmonds-Karp, que es una implementación del método de Ford-Fulkerson usando BFS para encontrar caminos aumentantes. La solución está implementada en JavaScript usando principios de Programación Orientada a Objetos (POO) y siguiendo las mejores prácticas de DRY (No te repitas).
+
+### Fragmento de Código Relevante
+
+```javascript
+class MaximumFlow {
+  constructor(graph) {
+    this.graph = graph;
+    this.n = graph.length;
+  }
+
+  bfs(source, sink, parent) {
+    const visited = new Array(this.n).fill(false);
+    const queue = [];
+    queue.push(source);
+    visited[source] = true;
+    parent[source] = -1;
+
+    while (queue.length > 0) {
+      const u = queue.shift();
+
+      for (let v = 0; v < this.n; v++) {
+        if (!visited[v] && this.graph[u][v] > 0) {
+          queue.push(v);
+          parent[v] = u;
+          visited[v] = true;
+        }
+      }
+    }
+    return visited[sink];
+  }
+
+  edmondsKarp(source, sink) {
+    const parent = new Array(this.n);
+    let maxFlow = 0;
+
+    while (this.bfs(source, sink, parent)) {
+      let pathFlow = Infinity;
+      for (let v = sink; v !== source; v = parent[v]) {
+        const u = parent[v];
+        pathFlow = Math.min(pathFlow, this.graph[u][v]);
+      }
+
+      for (let v = sink; v !== source; v = parent[v]) {
+        const u = parent[v];
+        this.graph[u][v] -= pathFlow;
+        this.graph[v][u] += pathFlow;
+      }
+
+      maxFlow += pathFlow;
+    }
+    return maxFlow;
+  }
+}
+```
+
+### Historia
+
+El problema de Flujo Máximo y el algoritmo de Edmonds-Karp han sido fundamentales en la teoría de flujos de red desde los años 50. El algoritmo de Edmonds-Karp mejora el método de Ford-Fulkerson usando BFS para encontrar los caminos aumentantes más cortos, asegurando una complejidad polinómica.

3-HARD/JavaScript/2-maximum-flow-edmonds-karp/proposed-solution/MaximumFlow.js

@@ -0,0 +1,53 @@
+// MaximumFlow.js - Edmonds-Karp algorithm implementation using OOP and DRY principles
+
+class MaximumFlow {
+  constructor(graph) {
+    this.graph = graph;
+    this.n = graph.length;
+  }
+
+  bfs(source, sink, parent) {
+    const visited = new Array(this.n).fill(false);
+    const queue = [];
+    queue.push(source);
+    visited[source] = true;
+    parent[source] = -1;
+
+    while (queue.length > 0) {
+      const u = queue.shift();
+
+      for (let v = 0; v < this.n; v++) {
+        if (!visited[v] && this.graph[u][v] > 0) {
+          queue.push(v);
+          parent[v] = u;
+          visited[v] = true;
+        }
+      }
+    }
+    return visited[sink];
+  }
+
+  edmondsKarp(source, sink) {
+    const parent = new Array(this.n);
+    let maxFlow = 0;
+
+    while (this.bfs(source, sink, parent)) {
+      let pathFlow = Infinity;
+      for (let v = sink; v !== source; v = parent[v]) {
+        const u = parent[v];
+        pathFlow = Math.min(pathFlow, this.graph[u][v]);
+      }
+
+      for (let v = sink; v !== source; v = parent[v]) {
+        const u = parent[v];
+        this.graph[u][v] -= pathFlow;
+        this.graph[v][u] += pathFlow;
+      }
+
+      maxFlow += pathFlow;
+    }
+    return maxFlow;
+  }
+}
+
+export default MaximumFlow;

3-HARD/JavaScript/2-maximum-flow-edmonds-karp/proposed-solution/main.js

@@ -0,0 +1,27 @@
+/*
+Challenge:  
+Implement the Edmonds-Karp algorithm to find the maximum flow in a flow network.  
+Given a directed graph where each edge has a capacity, find the maximum flow from a source node to a sink node.
+
+This solution uses Object-Oriented Programming (OOP) principles and follows DRY (Don't Repeat Yourself) best practices.
+*/
+
+import MaximumFlow from "./MaximumFlow.js";
+
+function main() {
+  // Example graph represented as an adjacency matrix of capacities
+  const 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],
+  ];
+
+  const maxFlowSolver = new MaximumFlow(graph);
+  const maxFlow = maxFlowSolver.edmondsKarp(0, 5);
+  console.log("The maximum possible flow is:", maxFlow);
+}
+
+main();