Remove BellmanFordAdjacencyMatrix, migrate tests to BellmanFordEdgeList (#1294)

The adjacency matrix variant is redundant with BellmanFordEdgeList and
BellmanFordAdjacencyList. Tests that used it as an oracle now use
BellmanFordEdgeList instead.

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: williamfiset

README.md

@@ -204,7 +204,6 @@ $ java -cp classes com.williamfiset.algorithms.search.BinarySearch
 - [Articulation points/cut vertices (adjacency list)](src/main/java/com/williamfiset/algorithms/graphtheory/ArticulationPointsAdjacencyList.java) **- O(V+E)**
 - [Bellman-Ford (edge list, negative cycles, fast & optimized)](src/main/java/com/williamfiset/algorithms/graphtheory/BellmanFordEdgeList.java) **- O(VE)**
 - [:movie_camera:](https://www.youtube.com/watch?v=lyw4FaxrwHg) [Bellman-Ford (adjacency list, negative cycles)](src/main/java/com/williamfiset/algorithms/graphtheory/BellmanFordAdjacencyList.java) **- O(VE)**
-- [Bellman-Ford (adjacency matrix, negative cycles)](src/main/java/com/williamfiset/algorithms/graphtheory/BellmanFordAdjacencyMatrix.java) **- O(V<sup>3</sup>)**
 - [:movie_camera:](https://www.youtube.com/watch?v=oDqjPvD54Ss) [Breadth first search (adjacency list)](src/main/java/com/williamfiset/algorithms/graphtheory/BreadthFirstSearchAdjacencyListIterative.java) **- O(V+E)**
 - [Breadth first search (adjacency list, fast queue)](src/main/java/com/williamfiset/algorithms/graphtheory/BreadthFirstSearchAdjacencyListIterativeFastQueue.java) **- O(V+E)**
 - [Bridges/cut edges (adjacency list)](src/main/java/com/williamfiset/algorithms/graphtheory/BridgesAdjacencyList.java) **- O(V+E)**

src/main/java/com/williamfiset/algorithms/graphtheory/BUILD

@@ -41,13 +41,6 @@ java_binary(
     runtime_deps = [":graphtheory"],
 )
 
-# bazel run //src/main/java/com/williamfiset/algorithms/graphtheory:BellmanFordAdjacencyMatrix
-java_binary(
-    name = "BellmanFordAdjacencyMatrix",
-    main_class = "com.williamfiset.algorithms.graphtheory.BellmanFordAdjacencyMatrix",
-    runtime_deps = [":graphtheory"],
-)
-
 # bazel run //src/main/java/com/williamfiset/algorithms/graphtheory:BellmanFordEdgeList
 java_binary(
     name = "BellmanFordEdgeList",

src/main/java/com/williamfiset/algorithms/graphtheory/BellmanFordAdjacencyMatrix.java

@@ -13,6 +13,8 @@
 import java.util.List;
 import org.junit.jupiter.api.*;
 
+import com.williamfiset.algorithms.graphtheory.BellmanFordEdgeList;
+
 public class BreadthFirstSearchAdjacencyListIterativeTest {
 
   BreadthFirstSearchAdjacencyListIterative solver;
@@ -82,11 +84,23 @@ public void testShortestPathAgainstBellmanFord() {
       int s = (int) (random() * n);
       int e = (int) (random() * n);
       solver = new BreadthFirstSearchAdjacencyListIterative(graph);
-      BellmanFordAdjacencyMatrix bfSolver = new BellmanFordAdjacencyMatrix(s, graph2);
+
+      // Convert adjacency matrix to edge list for BellmanFord
+      List<BellmanFordEdgeList.Edge> edgeList = new ArrayList<>();
+      for (int u = 0; u < n; u++) {
+        for (int v = 0; v < n; v++) {
+          if (u != v && graph2[u][v] != Double.POSITIVE_INFINITY) {
+            edgeList.add(new BellmanFordEdgeList.Edge(u, v, graph2[u][v]));
+          }
+        }
+      }
+      BellmanFordEdgeList.Edge[] edges = edgeList.toArray(new BellmanFordEdgeList.Edge[0]);
+      double[] dist = BellmanFordEdgeList.bellmanFord(edges, n, s);
 
       List<Integer> p1 = solver.reconstructPath(s, e);
-      List<Integer> p2 = bfSolver.reconstructShortestPath(e);
-      assertThat(p1.size()).isEqualTo(p2.size());
+      // All edges have weight 1, so BF distance equals number of edges = path size - 1
+      int expectedPathSize = (dist[e] == Double.POSITIVE_INFINITY) ? 0 : (int) dist[e] + 1;
+      assertThat(p1.size()).isEqualTo(expectedPathSize);
     }
   }
 

src/test/java/com/williamfiset/algorithms/graphtheory/BreadthFirstSearchAdjacencyListIterativeTest.java

@@ -2,6 +2,7 @@
 
 import static com.google.common.truth.Truth.assertThat;
 
+import com.williamfiset.algorithms.graphtheory.BellmanFordEdgeList.Edge;
 import java.util.*;
 import org.junit.jupiter.api.*;
 
@@ -51,6 +52,20 @@ private static double[][] createMatrix(int n) {
     return m;
   }
 
+  /** Converts an adjacency matrix to an array of BellmanFordEdgeList edges. */
+  private static Edge[] matrixToEdges(double[][] matrix) {
+    int n = matrix.length;
+    List<Edge> edges = new ArrayList<>();
+    for (int i = 0; i < n; i++) {
+      for (int j = 0; j < n; j++) {
+        if (i != j && matrix[i][j] != Double.POSITIVE_INFINITY) {
+          edges.add(new Edge(i, j, matrix[i][j]));
+        }
+      }
+    }
+    return edges.toArray(new Edge[0]);
+  }
+
   private static void addRandomEdges(double[][] matrix, int count, boolean allowNegativeEdges) {
     int n = matrix.length;
     while (count-- > 0) {
@@ -125,7 +140,7 @@ public void testApspAgainstBellmanFord_nonNegativeEdgeWeights() {
         double[][] fw = new FloydWarshallSolver(m).getApspMatrix();
 
         for (int s = 0; s < n; s++) {
-          double[] bf = new BellmanFordAdjacencyMatrix(s, m).getShortestPaths();
+          double[] bf = BellmanFordEdgeList.bellmanFord(matrixToEdges(m), n, s);
           assertThat(bf).isEqualTo(fw[s]);
         }
       }
@@ -144,7 +159,7 @@ public void testApspAgainstBellmanFord_withNegativeEdgeWeights() {
         double[][] fw = new FloydWarshallSolver(m).getApspMatrix();
 
         for (int s = 0; s < n; s++) {
-          double[] bf = new BellmanFordAdjacencyMatrix(s, m).getShortestPaths();
+          double[] bf = BellmanFordEdgeList.bellmanFord(matrixToEdges(m), n, s);
           assertThat(bf).isEqualTo(fw[s]);
         }
       }
@@ -165,15 +180,16 @@ public void testPathReconstructionBellmanFord_nonNegativeEdgeWeights() {
         FloydWarshallSolver fwSolver = new FloydWarshallSolver(m);
         fwSolver.solve();
 
+        Edge[] edges = matrixToEdges(m);
         for (int s = 0; s < n; s++) {
-          BellmanFordAdjacencyMatrix bfSolver = new BellmanFordAdjacencyMatrix(s, m);
+          double[] bf = BellmanFordEdgeList.bellmanFord(edges, n, s);
           for (int e = 0; e < n; e++) {
 
-            // Make sure that if 'fwp' returns null that 'bfp' also returns null or
-            // that if 'fwp' is not null that 'bfp' is also not null.
+            // FW returns null path when a negative cycle exists on the shortest path.
+            // BF marks such nodes with -Infinity. Verify they agree.
             List<Integer> fwp = fwSolver.reconstructShortestPath(s, e);
-            List<Integer> bfp = bfSolver.reconstructShortestPath(e);
-            if ((fwp == null) ^ (bfp == null)) {
+            boolean bfNegCycle = (bf[e] == Double.NEGATIVE_INFINITY);
+            if ((fwp == null) != bfNegCycle) {
               org.junit.Assert.fail("Mismatch.");
             }
           }