refactor

Author: Samuel Facchinello

src/main/java/com/thealgorithms/backtracking/AllPathsFromSourceToTarget.java

@@ -1,102 +1,100 @@
-/**
- * Author : Siddhant Swarup Mallick
- * Github : https://github.com/siddhant2002
- */
-
-/** Program description - To find all possible paths from source to destination*/
-
-/**Wikipedia link -> https://en.wikipedia.org/wiki/Shortest_path_problem */
 package com.thealgorithms.backtracking;
 
 import java.util.ArrayList;
 import java.util.List;
 
+/**
+ * To find all possible paths from source to destination. See
+ * <a href="https://en.wikipedia.org/wiki/Shortest_path_problem">Wikipedia</a>
+ * (Note: This algorithm finds all paths, not the shortest paths).
+ */
 public class AllPathsFromSourceToTarget {
 
-    // No. of vertices in graph
-    private final int v;
-
-    // To store the paths from source to destination
-    static List<List<Integer>> nm = new ArrayList<>();
-    // adjacency list
-    private ArrayList<Integer>[] adjList;
-
-    // Constructor
-    public AllPathsFromSourceToTarget(int vertices) {
+    private final int vertexCount;
+    private final List<List<Integer>> allPaths;
+    private final List<Integer>[] adjList;
 
-        // initialise vertex count
-        this.v = vertices;
-
-        // initialise adjacency list
-        initAdjList();
+    private AllPathsFromSourceToTarget(int vertices) {
+        this.vertexCount = vertices;
+        this.allPaths = new ArrayList<>();
+        this.adjList = new ArrayList[vertices];
+        initializeAdjacencyList();
     }
 
-    // utility method to initialise adjacency list
-    private void initAdjList() {
-        adjList = new ArrayList[v];
-
-        for (int i = 0; i < v; i++) {
+    /**
+     * Initializes the adjacency list to represent a graph with the specified number of vertices.
+     */
+    private void initializeAdjacencyList() {
+        for (int i = 0; i < vertexCount; i++) {
             adjList[i] = new ArrayList<>();
         }
     }
 
-    // add edge from u to v
-    public void addEdge(int u, int v) {
-        // Add v to u's list.
-        adjList[u].add(v);
+    /**
+     * Adds a directed edge from source vertex to destination vertex in the graph.
+     * @param source The starting vertex of the edge.
+     * @param destination The ending vertex of the edge.
+     */
+    private void addEdge(int source, int destination) {
+        adjList[source].add(destination);
     }
 
-    public void storeAllPaths(int s, int d) {
-        boolean[] isVisited = new boolean[v];
-        ArrayList<Integer> pathList = new ArrayList<>();
-
-        // add source to path[]
-        pathList.add(s);
-        // Call recursive utility
-        storeAllPathsUtil(s, d, isVisited, pathList);
+    /**
+     * Finds all possible paths from a given source vertex to a destination vertex in the graph.
+     * This method uses a backtracking approach to explore all possible paths.
+     * @param source The starting vertex of the path search.
+     * @param destination The ending vertex of the path search.
+     * @return A list containing all the found paths represented as lists of vertex indices.
+     */
+    private List<List<Integer>> findAllPaths(int source, int destination) {
+        boolean[] visited = new boolean[vertexCount];
+        List<Integer> currentPath = new ArrayList<>();
+        currentPath.add(source);
+        findAllPathsUtil(source, destination, visited, currentPath);
+        return allPaths;
     }
 
-    // A recursive function to print all paths from 'u' to 'd'.
-    // isVisited[] keeps track of vertices in current path.
-    // localPathList<> stores actual vertices in the current path
-    private void storeAllPathsUtil(Integer u, Integer d, boolean[] isVisited, List<Integer> localPathList) {
-
-        if (u.equals(d)) {
-            nm.add(new ArrayList<>(localPathList));
+    /**
+     * A recursive helper function that implements the backtracking logic to find all paths.
+     * @param source The current vertex being explored in the path search.
+     * @param destination The ending vertex of the path search.
+     * @param visited A boolean array to keep track of visited vertices.
+     * @param currentPath A list representing the current path being constructed.
+     */
+    private void findAllPathsUtil(int source, int destination, boolean[] visited, List<Integer> currentPath) {
+        if (source == destination) {
+            allPaths.add(new ArrayList<>(currentPath));
             return;
         }
 
-        // Mark the current node
-        isVisited[u] = true;
+        visited[source] = true;
 
-        // Recursion for all the vertices adjacent to current vertex
-
-        for (Integer i : adjList[u]) {
-            if (!isVisited[i]) {
-                // store current node in path[]
-                localPathList.add(i);
-                storeAllPathsUtil(i, d, isVisited, localPathList);
-
-                // remove current node in path[]
-                localPathList.remove(i);
+        for (int neighbor : adjList[source]) {
+            if (!visited[neighbor]) {
+                currentPath.add(neighbor);
+                findAllPathsUtil(neighbor, destination, visited, currentPath);
+                currentPath.removeLast();
             }
         }
 
-        // Mark the current node
-        isVisited[u] = false;
+        visited[source] = false;
     }
 
-    // Driver program
-    public static List<List<Integer>> allPathsFromSourceToTarget(int vertices, int[][] a, int source, int destination) {
-        // Create a sample graph
+
+    /**
+     * Finds all possible paths from a given source vertex to a destination vertex in the graph.
+     * This method uses a backtracking approach to explore all possible paths.
+     * The found paths are stored in the `allPaths` member variable.
+     *
+     * @param source The starting vertex of the path search.
+     * @param destination The ending vertex of the path search.
+     * @return A list containing all the found paths represented as lists of vertex indices.
+     */
+    public static List<List<Integer>> findAllPaths(int vertices, int[][] a, int source, int destination) {
         AllPathsFromSourceToTarget g = new AllPathsFromSourceToTarget(vertices);
         for (int[] i : a) {
             g.addEdge(i[0], i[1]);
-            // edges are added
         }
-        g.storeAllPaths(source, destination);
-        // method call to store all possible paths
-        return nm;
-        // returns all possible paths from source to destination
+        return g.findAllPaths(source, destination);
     }
 }

src/test/java/com/thealgorithms/backtracking/AllPathsFromSourceToTargetTest.java

@@ -14,7 +14,7 @@ void testForFirstCase() {
         int source = 2;
         int destination = 3;
         List<List<Integer>> expected = List.of(List.of(2, 0, 1, 3), List.of(2, 0, 3), List.of(2, 1, 3));
-        List<List<Integer>> actual = AllPathsFromSourceToTarget.allPathsFromSourceToTarget(vertices, a, source, destination);
+        List<List<Integer>> actual = AllPathsFromSourceToTarget.findAllPaths(vertices, a, source, destination);
 
         assertIterableEquals(expected, actual);
     }
@@ -26,7 +26,7 @@ void testForSecondCase() {
         int source = 0;
         int destination = 4;
         List<List<Integer>> expected = List.of(List.of(0, 1, 3, 4), List.of(0, 1, 4), List.of(0, 2, 1, 3, 4), List.of(0, 2, 1, 4), List.of(0, 2, 4), List.of(0, 3, 4));
-        List<List<Integer>> actual = AllPathsFromSourceToTarget.allPathsFromSourceToTarget(vertices, a, source, destination);
+        List<List<Integer>> actual = AllPathsFromSourceToTarget.findAllPaths(vertices, a, source, destination);
 
         assertIterableEquals(expected, actual);
     }
@@ -38,19 +38,19 @@ void testForThirdCase() {
         int source = 1;
         int destination = 5;
         List<List<Integer>> expected = List.of(List.of(1, 0, 2, 5), List.of(1, 0, 5), List.of(1, 5), List.of(1, 2, 5));
-        List<List<Integer>> actual = AllPathsFromSourceToTarget.allPathsFromSourceToTarget(vertices, a, source, destination);
+        List<List<Integer>> actual = AllPathsFromSourceToTarget.findAllPaths(vertices, a, source, destination);
 
         assertIterableEquals(expected, actual);
     }
 
     @Test
-    void testForFourthcase() {
+    void testForFourthCase() {
         int vertices = 3;
         int[][] a = {{0, 1}, {0, 2}, {1, 2}};
         int source = 0;
         int destination = 2;
         List<List<Integer>> expected = List.of(List.of(0, 1, 2), List.of(0, 2));
-        List<List<Integer>> actual = AllPathsFromSourceToTarget.allPathsFromSourceToTarget(vertices, a, source, destination);
+        List<List<Integer>> actual = AllPathsFromSourceToTarget.findAllPaths(vertices, a, source, destination);
 
         assertIterableEquals(expected, actual);
     }