Updated PrismAlgorithm-II

Author: shubham9345

src/main/java/com/thealgorithms/graph/PrismAlgorithm.java renamed to src/main/java/com/thealgorithms/graph/PrimAlgorithm.java

@@ -3,32 +3,23 @@
 import java.util.ArrayList;
 import java.util.PriorityQueue;
 
-
 /**
- * A helper class representing an edge with its
- * associated weight and the connected node.
+ * This class provides a method to compute the weight of the
+ * Minimum Spanning Tree (MST) of a graph using Prim's Algorithm.
  */
-class Pair {
-    int node;
-    int weight;
+public final class PrimAlgorithm {
+
+    private PrimAlgorithm() {
+        throw new UnsupportedOperationException("Utility class");
+    }
 
     /**
-     * Constructs a Pair object to hold an edge's weight and node.
+     * Helper record representing an edge with its associated weight and node.
      *
-     * @param weight The weight of the edge.
-     * @param node   The target node connected by the edge.
+     * @param node   the target node connected by the edge
+     * @param weight the weight of the edge
      */
-    public Pair(int weight, int node) {
-        this.node = node;
-        this.weight = weight;
-    }
-}
-
-/**
- * This class provides a method to compute the weight of the
- * Minimum Spanning Tree (MST) of a graph using Prim's Algorithm.
- */
-public class PrismAlgorithm {
+    private record Pair(int node, int weight) {}
 
     /**
      * Computes the total weight of the Minimum Spanning Tree (MST)
@@ -38,23 +29,22 @@ public class PrismAlgorithm {
      * the edge with the smallest weight that connects a new vertex to
      * the growing MST. It ensures that no cycles are formed.</p>
      *
-     * @param V   Number of vertices in the graph.
-     * @param adj Adjacency list representation of the graph.
-     *            For each node, the adjacency list contains a list of
-     *            {adjacentNode, edgeWeight}.
-     * @return The sum of the edge weights in the MST.
+     * @param V   number of vertices in the graph
+     * @param adj adjacency list representation of the graph
+     *            for each node, the adjacency list contains a list of
+     *            {adjacentNode, edgeWeight}
+     * @return the sum of the edge weights in the MST
      *
-     * <p>Time Complexity: O(E log V) where E is the number of edges
+     * <p>Time Complexity: O(E log V), where E is the number of edges
      * and V is the number of vertices.</p>
      * <p>Space Complexity: O(V + E) due to adjacency list and visited array.</p>
      */
-    static int spanningTree(int V, ArrayList<ArrayList<ArrayList<Integer>>> adj) {
-
+    public static int spanningTree(int V, ArrayList<ArrayList<ArrayList<Integer>>> adj) {
         // Min-heap to pick edge with the smallest weight
         PriorityQueue<Pair> pq = new PriorityQueue<>((x, y) -> x.weight - y.weight);
 
         // Array to keep track of visited vertices
-        int[] visited = new int[V];
+        boolean[] visited = new boolean[V];
 
         // Start with node 0 (arbitrary choice), with edge weight = 0
         pq.add(new Pair(0, 0));
@@ -64,24 +54,26 @@ static int spanningTree(int V, ArrayList<ArrayList<ArrayList<Integer>>> adj) {
         // Process nodes until the priority queue is empty
         while (!pq.isEmpty()) {
             Pair current = pq.poll();
-            int weight = current.weight;
-            int node = current.node;
+            int node = current.node();
+            int weight = current.weight();
 
             // Skip if the node is already included in MST
-            if (visited[node] == 1) continue;
+            if (visited[node]) {
+                continue;
+            }
 
             // Include the node in MST
-            visited[node] = 1;
+            visited[node] = true;
             mstWeightSum += weight;
 
             // Traverse all adjacent edges
-            for (int i = 0; i < adj.get(node).size(); i++) {
-                int adjNode = adj.get(node).get(i).get(0);
-                int edgeWeight = adj.get(node).get(i).get(1);
+            for (ArrayList<Integer> edge : adj.get(node)) {
+                int adjNode = edge.get(0);
+                int edgeWeight = edge.get(1);
 
                 // Only consider unvisited nodes
-                if (visited[adjNode] == 0) {
-                    pq.add(new Pair(edgeWeight, adjNode));
+                if (!visited[adjNode]) {
+                    pq.add(new Pair(adjNode, edgeWeight));
                 }
             }
         }