Refactor DFS recursive: simplify, add docs, clean up example

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: williamfiset

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

@@ -1,86 +1,74 @@
 /**
- * An implementation of a recursive approach to DFS Time Complexity: O(V + E)
+ * Depth-First Search — Adjacency List (Recursive)
+ *
+ * <p>Performs a recursive DFS traversal on a directed graph represented as an
+ * adjacency list, counting the number of reachable nodes from a given source.
+ *
+ * <p>Time:  O(V + E)
+ * <p>Space: O(V)
  *
  * @author William Fiset, william.alexandre.fiset@gmail.com
  */
 package com.williamfiset.algorithms.graphtheory;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.List;
 
 public class DepthFirstSearchAdjacencyListRecursive {
 
-  static class Edge {
-    int from, to, cost;
-
-    public Edge(int from, int to, int cost) {
-      this.from = from;
-      this.to = to;
-      this.cost = cost;
-    }
+  /**
+   * Returns the number of nodes reachable from {@code start} (including itself).
+   */
+  static int dfs(int start, List<List<Integer>> graph) {
+    return dfs(start, new boolean[graph.size()], graph);
   }
 
-  // Perform a depth first search on the graph counting
-  // the number of nodes traversed starting at some position
-  static long dfs(int at, boolean[] visited, Map<Integer, List<Edge>> graph) {
-
-    // We have already visited this node
-    if (visited[at]) return 0L;
-
-    // Visit this node
+  private static int dfs(int at, boolean[] visited, List<List<Integer>> graph) {
+    if (visited[at]) {
+      return 0;
+    }
     visited[at] = true;
-    long count = 1;
-
-    // Visit all edges adjacent to where we're at
-    List<Edge> edges = graph.get(at);
-    if (edges != null) {
-      for (Edge edge : edges) {
-        count += dfs(edge.to, visited, graph);
-      }
+    int count = 1;
+    for (int to : graph.get(at)) {
+      count += dfs(to, visited, graph);
     }
-
     return count;
   }
 
-  // Example usage of DFS
-  public static void main(String[] args) {
+  // ==================== Main ====================
 
-    // Create a fully connected graph
-    //           (0)
-    //           / \
-    //        5 /   \ 4
-    //         /     \
-    // 10     <   -2  >
-    //   +->(2)<------(1)      (4)
-    //   +--- \       /
-    //         \     /
-    //        1 \   / 6
-    //           > <
-    //           (3)
-    int numNodes = 5;
-    Map<Integer, List<Edge>> graph = new HashMap<>();
-    addDirectedEdge(graph, 0, 1, 4);
-    addDirectedEdge(graph, 0, 2, 5);
-    addDirectedEdge(graph, 1, 2, -2);
-    addDirectedEdge(graph, 1, 3, 6);
-    addDirectedEdge(graph, 2, 3, 1);
-    addDirectedEdge(graph, 2, 2, 10); // Self loop
+  //
+  //    0 ---> 1 ---> 3
+  //    |      |
+  //    v      v
+  //    2      4 ---> 5       6
+  //
+  //  DFS from 0: 6 nodes
+  //  DFS from 6: 1 node
+  //
+  public static void main(String[] args) {
+    int n = 7;
+    List<List<Integer>> graph = createGraph(n);
 
-    long nodeCount = dfs(0, new boolean[numNodes], graph);
-    System.out.println("DFS node count starting at node 0: " + nodeCount);
-    if (nodeCount != 4) System.err.println("Error with DFS");
+    addDirectedEdge(graph, 0, 1);
+    addDirectedEdge(graph, 0, 2);
+    addDirectedEdge(graph, 1, 3);
+    addDirectedEdge(graph, 1, 4);
+    addDirectedEdge(graph, 4, 5);
 
-    nodeCount = dfs(4, new boolean[numNodes], graph);
-    System.out.println("DFS node count starting at node 4: " + nodeCount);
-    if (nodeCount != 1) System.err.println("Error with DFS");
+    System.out.println("DFS from 0: " + dfs(0, graph) + " nodes");
+    System.out.println("DFS from 6: " + dfs(6, graph) + " nodes");
   }
 
-  // Helper method to setup graph
-  private static void addDirectedEdge(Map<Integer, List<Edge>> graph, int from, int to, int cost) {
-    List<Edge> list = graph.get(from);
-    if (list == null) {
-      list = new ArrayList<Edge>();
-      graph.put(from, list);
+  private static List<List<Integer>> createGraph(int n) {
+    List<List<Integer>> graph = new ArrayList<>(n);
+    for (int i = 0; i < n; i++) {
+      graph.add(new ArrayList<>());
     }
-    list.add(new Edge(from, to, cost));
+    return graph;
+  }
+
+  private static void addDirectedEdge(List<List<Integer>> graph, int from, int to) {
+    graph.get(from).add(to);
   }
 }