style: fix Checkstyle in Yens algorithm and tests

Author: SamXop123

src/main/java/com/thealgorithms/graph/YensKShortestPaths.java

@@ -42,18 +42,18 @@ public static List<List<Integer>> kShortestPaths(int[][] weights, int src, int d
             w[i] = Arrays.copyOf(weights[i], n);
         }
 
-        List<Path> A = new ArrayList<>();
-        PriorityQueue<Path> B = new PriorityQueue<>(); // min-heap by cost then lexicographic nodes
+        List<Path> a = new ArrayList<>();
+        PriorityQueue<Path> b = new PriorityQueue<>(); // min-heap by cost then lexicographic nodes
         Set<String> seen = new HashSet<>(); // deduplicate candidate paths by node sequence key
 
         Path first = dijkstra(w, src, dst, new boolean[n]);
         if (first == null) {
             return List.of();
         }
-        A.add(first);
+        a.add(first);
 
         for (int kIdx = 1; kIdx < k; kIdx++) {
-            Path lastPath = A.get(kIdx - 1);
+            Path lastPath = a.get(kIdx - 1);
             List<Integer> lastNodes = lastPath.nodes;
             for (int i = 0; i < lastNodes.size() - 1; i++) {
                 int spurNode = lastNodes.get(i);
@@ -62,7 +62,7 @@ public static List<List<Integer>> kShortestPaths(int[][] weights, int src, int d
                 // Build modified graph: remove edges that would recreate same root + next edge as any A path
                 int[][] wMod = cloneMatrix(w);
 
-                for (Path p : A) {
+                for (Path p : a) {
                     if (startsWith(p.nodes, rootPath) && p.nodes.size() > i + 1) {
                         int u = p.nodes.get(i);
                         int v = p.nodes.get(i + 1);
@@ -88,20 +88,20 @@ public static List<List<Integer>> kShortestPaths(int[][] weights, int src, int d
                     Path candidate = new Path(totalNodes, totalCost);
                     String key = candidate.key();
                     if (!seen.contains(key)) {
-                        B.add(candidate);
+                        b.add(candidate);
                         seen.add(key);
                     }
                 }
             }
-            if (B.isEmpty()) {
+            if (b.isEmpty()) {
                 break;
             }
-            A.add(B.poll());
+            a.add(b.poll());
         }
 
         // Map to list of node indices for output
-        List<List<Integer>> result = new ArrayList<>(A.size());
-        for (Path p : A) {
+        List<List<Integer>> result = new ArrayList<>(a.size());
+        for (Path p : a) {
             result.add(new ArrayList<>(p.nodes));
         }
         return result;
@@ -135,46 +135,61 @@ private static void validate(int[][] weights, int src, int dst, int k) {
     }
 
     private static boolean startsWith(List<Integer> list, List<Integer> prefix) {
-        if (prefix.size() > list.size()) return false;
+        if (prefix.size() > list.size()) {
+            return false;
+        }
         for (int i = 0; i < prefix.size(); i++) {
-            if (!Objects.equals(list.get(i), prefix.get(i))) return false;
+            if (!Objects.equals(list.get(i), prefix.get(i))) {
+                return false;
+            }
         }
         return true;
     }
 
     private static int[][] cloneMatrix(int[][] a) {
         int n = a.length;
         int[][] b = new int[n][n];
-        for (int i = 0; i < n; i++) b[i] = Arrays.copyOf(a[i], n);
+        for (int i = 0; i < n; i++) {
+            b[i] = Arrays.copyOf(a[i], n);
+        }
         return b;
     }
 
     private static long pathCost(int[][] w, List<Integer> nodes) {
         long cost = 0;
         for (int i = 0; i + 1 < nodes.size(); i++) {
-            int u = nodes.get(i), v = nodes.get(i + 1);
+            int u = nodes.get(i);
+            int v = nodes.get(i + 1);
             int c = w[u][v];
-            if (c < 0) return Long.MAX_VALUE / 4; // invalid
+            if (c < 0) {
+                return Long.MAX_VALUE / 4; // invalid
+            }
             cost += c;
         }
         return cost;
     }
 
     private static Path dijkstra(int[][] w, int src, int dst, boolean[] blocked) {
         int n = w.length;
-        final long INF = Long.MAX_VALUE / 4;
+        final long inf = Long.MAX_VALUE / 4;
         long[] dist = new long[n];
         int[] parent = new int[n];
-        Arrays.fill(dist, INF);
+        Arrays.fill(dist, inf);
         Arrays.fill(parent, -1);
         PriorityQueue<Node> pq = new PriorityQueue<>();
-        if (blocked[src]) return null;
+        if (blocked[src]) {
+            return null;
+        }
         dist[src] = 0;
         pq.add(new Node(src, 0));
         while (!pq.isEmpty()) {
             Node cur = pq.poll();
-            if (cur.dist != dist[cur.u]) continue;
-            if (cur.u == dst) break;
+            if (cur.dist != dist[cur.u]) {
+                continue;
+            }
+            if (cur.u == dst) {
+                break;
+            }
             for (int v = 0; v < n; v++) {
                 int wuv = w[cur.u][v];
                 if (wuv >= 0 && !blocked[v]) {
@@ -187,7 +202,7 @@ private static Path dijkstra(int[][] w, int src, int dst, boolean[] blocked) {
                 }
             }
         }
-        if (dist[dst] >= INF) {
+        if (dist[dst] >= inf) {
             // If src==dst and not blocked, the path is trivial with cost 0
             if (src == dst) {
                 List<Integer> nodes = new ArrayList<>();
@@ -231,12 +246,17 @@ String key() {
         @Override
         public int compareTo(Path o) {
             int c = Long.compare(this.cost, o.cost);
-            if (c != 0) return c;
+            if (c != 0) {
+                return c;
+            }
             // tie-break lexicographically on nodes
             int m = Math.min(this.nodes.size(), o.nodes.size());
             for (int i = 0; i < m; i++) {
-                int a = this.nodes.get(i), b = o.nodes.get(i);
-                if (a != b) return Integer.compare(a, b);
+                int aNode = this.nodes.get(i);
+                int bNode = o.nodes.get(i);
+                if (aNode != bNode) {
+                    return Integer.compare(aNode, bNode);
+                }
             }
             return Integer.compare(this.nodes.size(), o.nodes.size());
         }

src/test/java/com/thealgorithms/graph/YensKShortestPathsTest.java

@@ -14,10 +14,10 @@ class YensKShortestPathsTest {
     void basicKPaths() {
         // Graph (directed) with non-negative weights, -1 = no edge
         // 0 -> 1 (1), 0 -> 2 (2), 1 -> 3 (1), 2 -> 3 (1), 0 -> 3 (5), 1 -> 2 (1)
-        int N = 4;
-        int[][] w = new int[N][N];
-        for (int i = 0; i < N; i++) {
-            for (int j = 0; j < N; j++) {
+        int n = 4;
+        int[][] w = new int[n][n];
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
                 w[i][j] = -1;
             }
         }