Merge branch 'master' into master

Author: khwaishchawla

src/main/java/com/thealgorithms/datastructures/graphs/HamiltonianCycle.java

@@ -1,8 +1,14 @@
 package com.thealgorithms.datastructures.graphs;
 
+import java.util.Arrays;
+
 /**
- * Java program for Hamiltonian Cycle
- * <a href="https://en.wikipedia.org/wiki/Hamiltonian_path">wikipedia</a>
+ * Java program to find a Hamiltonian Cycle in a graph.
+ * A Hamiltonian Cycle is a cycle that visits every vertex exactly once
+ * and returns to the starting vertex.
+ *
+ * <p>For more details, see the
+ * <a href="https://en.wikipedia.org/wiki/Hamiltonian_path">Wikipedia article</a>.
  *
  * @author  <a href="https://github.com/itsAkshayDubey">Akshay Dubey</a>
  */
@@ -14,30 +20,30 @@ public class HamiltonianCycle {
     private int[][] graph;
 
     /**
-     * Find hamiltonian cycle for given graph G(V,E)
+     * Finds a Hamiltonian Cycle for the given graph.
      *
-     * @param graph Adjacency matrix of a graph G(V, E)
-     *              for which hamiltonian path is to be found
-     * @return Array containing hamiltonian cycle
-     *         else returns 1D array with value -1.
+     * @param graph Adjacency matrix representing the graph G(V, E), where V is
+     *              the set of vertices and E is the set of edges.
+     * @return An array representing the Hamiltonian cycle if found, otherwise an
+     *         array filled with -1 indicating no Hamiltonian cycle exists.
      */
     public int[] findHamiltonianCycle(int[][] graph) {
+        // Single vertex graph
+        if (graph.length == 1) {
+            return new int[] {0, 0};
+        }
+
         this.vertex = graph.length;
         this.cycle = new int[this.vertex + 1];
 
-        // Initialize path array with -1 value
-        for (int i = 0; i < this.cycle.length; i++) {
-            this.cycle[i] = -1;
-        }
+        // Initialize the cycle array with -1 to represent unvisited vertices
+        Arrays.fill(this.cycle, -1);
 
         this.graph = graph;
-
         this.cycle[0] = 0;
         this.pathCount = 1;
         if (!isPathFound(0)) {
-            for (int i = 0; i < this.cycle.length; i++) {
-                this.cycle[i] = -1;
-            }
+            Arrays.fill(this.cycle, -1);
         } else {
             this.cycle[this.cycle.length - 1] = this.cycle[0];
         }
@@ -46,62 +52,55 @@ public int[] findHamiltonianCycle(int[][] graph) {
     }
 
     /**
-     * function to find paths recursively
-     * Find paths recursively from given vertex
+     * Recursively searches for a Hamiltonian cycle from the given vertex.
      *
-     * @param vertex Vertex from which path is to be found
-     * @returns true if path is found false otherwise
+     * @param vertex The current vertex from which to explore paths.
+     * @return {@code true} if a Hamiltonian cycle is found, otherwise {@code false}.
      */
     public boolean isPathFound(int vertex) {
         boolean isLastVertexConnectedToStart = this.graph[vertex][0] == 1 && this.pathCount == this.vertex;
         if (isLastVertexConnectedToStart) {
             return true;
         }
 
-        /* all vertices selected but last vertex not linked to 0 **/
+        // If all vertices are visited but the last vertex is not connected to the start
         if (this.pathCount == this.vertex) {
             return false;
         }
 
         for (int v = 0; v < this.vertex; v++) {
-            /* if connected **/
-            if (this.graph[vertex][v] == 1) {
-                /* add to path **/
-                this.cycle[this.pathCount++] = v;
-
-                /* remove connection **/
+            if (this.graph[vertex][v] == 1) { // Check if there is an edge
+                this.cycle[this.pathCount++] = v; // Add the vertex to the cycle
                 this.graph[vertex][v] = 0;
                 this.graph[v][vertex] = 0;
 
-                /* if vertex not already selected solve recursively **/
+                // Recursively attempt to complete the cycle
                 if (!isPresent(v)) {
                     return isPathFound(v);
                 }
 
-                /* restore connection **/
+                // Restore the edge if the path does not work
                 this.graph[vertex][v] = 1;
                 this.graph[v][vertex] = 1;
 
-                /* remove path **/
                 this.cycle[--this.pathCount] = -1;
             }
         }
         return false;
     }
 
     /**
-     * function to check if path is already selected
-     * Check if path is already selected
+     * Checks if a vertex is already part of the current Hamiltonian path.
      *
-     * @param vertex Starting vertex
+     * @param vertex The vertex to check.
+     * @return {@code true} if the vertex is already in the path, otherwise {@code false}.
      */
     public boolean isPresent(int vertex) {
         for (int i = 0; i < pathCount - 1; i++) {
             if (cycle[i] == vertex) {
                 return true;
             }
         }
-
         return false;
     }
 }

src/main/java/com/thealgorithms/datastructures/graphs/JohnsonsAlgorithm.java

@@ -21,17 +21,18 @@
  */
 public final class JohnsonsAlgorithm {
 
-    // Constant representing infinity
     private static final double INF = Double.POSITIVE_INFINITY;
 
-    /**
-     * A private constructor to hide the implicit public one.
-     */
     private JohnsonsAlgorithm() {
     }
 
     /**
      * Executes Johnson's algorithm on the given graph.
+     * Steps:
+     * 1. Add a new vertex to the graph and run Bellman-Ford to compute modified weights
+     * 2. t the graph using the modified weights
+     * 3. Run Dijkstra's algorithm for each vertex to compute the shortest paths
+     * The final result is a 2D array of shortest distances between all pairs of vertices.
      *
      * @param graph The input graph represented as an adjacency matrix.
      * @return A 2D array representing the shortest distances between all pairs of vertices.
@@ -40,13 +41,10 @@ public static double[][] johnsonAlgorithm(double[][] graph) {
         int numVertices = graph.length;
         double[][] edges = convertToEdgeList(graph);
 
-        // Step 1: Add a new vertex and run Bellman-Ford
         double[] modifiedWeights = bellmanFord(edges, numVertices);
 
-        // Step 2: Reweight the graph
         double[][] reweightedGraph = reweightGraph(graph, modifiedWeights);
 
-        // Step 3: Run Dijkstra's algorithm for each vertex
         double[][] shortestDistances = new double[numVertices][numVertices];
         for (int source = 0; source < numVertices; source++) {
             shortestDistances[source] = dijkstra(reweightedGraph, source, modifiedWeights);
@@ -74,7 +72,6 @@ public static double[][] convertToEdgeList(double[][] graph) {
             }
         }
 
-        // Convert the List to a 2D array
         return edgeList.toArray(new double[0][]);
     }
 
@@ -89,7 +86,7 @@ public static double[][] convertToEdgeList(double[][] graph) {
     private static double[] bellmanFord(double[][] edges, int numVertices) {
         double[] dist = new double[numVertices + 1];
         Arrays.fill(dist, INF);
-        dist[numVertices] = 0; // Distance to the new source vertex is 0
+        dist[numVertices] = 0;
 
         // Add edges from the new vertex to all original vertices
         double[][] allEdges = Arrays.copyOf(edges, edges.length + numVertices);

src/test/java/com/thealgorithms/datastructures/graphs/HamiltonianCycleTest.java

@@ -6,7 +6,7 @@
 
 class HamiltonianCycleTest {
 
-    private HamiltonianCycle hamiltonianCycle = new HamiltonianCycle();
+    private final HamiltonianCycle hamiltonianCycle = new HamiltonianCycle();
 
     @Test
     void testFindHamiltonianCycleShouldReturnHamiltonianCycle() {
@@ -36,4 +36,63 @@ void testFindHamiltonianCycleShouldReturnInfinityArray() {
 
         assertArrayEquals(expectedArray, hamiltonianCycle.findHamiltonianCycle(inputArray));
     }
+
+    @Test
+    void testSingleVertexGraph() {
+        int[] expectedArray = {0, 0};
+        int[][] inputArray = {{0}};
+
+        assertArrayEquals(expectedArray, hamiltonianCycle.findHamiltonianCycle(inputArray));
+    }
+
+    @Test
+    void testDisconnectedGraphShouldReturnInfinityArray() {
+        int[] expectedArray = {-1, -1, -1, -1, -1};
+        int[][] inputArray = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};
+
+        assertArrayEquals(expectedArray, hamiltonianCycle.findHamiltonianCycle(inputArray));
+    }
+
+    @Test
+    void testCompleteGraphShouldReturnHamiltonianCycle() {
+        int[] expectedArray = {0, 1, 2, 3, 4, 0};
+        int[][] inputArray = {
+            {0, 1, 1, 1, 1},
+            {1, 0, 1, 1, 1},
+            {1, 1, 0, 1, 1},
+            {1, 1, 1, 0, 1},
+            {1, 1, 1, 1, 0},
+        };
+
+        assertArrayEquals(expectedArray, hamiltonianCycle.findHamiltonianCycle(inputArray));
+    }
+
+    @Test
+    void testGraphWithNoEdgesShouldReturnInfinityArray() {
+        int[] expectedArray = {-1, -1, -1, -1, -1, -1};
+
+        int[][] inputArray = {
+            {0, 0, 0, 0, 0},
+            {0, 0, 0, 0, 0},
+            {0, 0, 0, 0, 0},
+            {0, 0, 0, 0, 0},
+            {0, 0, 0, 0, 0},
+        };
+
+        assertArrayEquals(expectedArray, hamiltonianCycle.findHamiltonianCycle(inputArray));
+    }
+
+    @Test
+    void testLargeGraphWithHamiltonianCycle() {
+        int[] expectedArray = {0, 1, 2, 3, 4, 0};
+        int[][] inputArray = {
+            {0, 1, 0, 1, 1},
+            {1, 0, 1, 1, 0},
+            {0, 1, 0, 1, 1},
+            {1, 1, 1, 0, 1},
+            {1, 0, 1, 1, 0},
+        };
+
+        assertArrayEquals(expectedArray, hamiltonianCycle.findHamiltonianCycle(inputArray));
+    }
 }