Removed changed in PartitionProblem.java, Renamed class name to be straightforward about the implementation.Added full names instead of shortcuts, and included record.

Author: StathisVeinoglou

src/main/java/com/thealgorithms/dynamicprogramming/PartitionProblem.java

@@ -1,4 +1,4 @@
-/*
+/**
  * @author Md Asif Joardar
  *
  * Description: The partition problem is a classic problem in computer science

src/main/java/com/thealgorithms/graph/GraphTraversal.java renamed to src/main/java/com/thealgorithms/graph/PredecessorConstrainedDfs.java

@@ -24,53 +24,46 @@
  * </p>
  */
 
-public final class GraphTraversal {
+public final class PredecessorConstrainedDfs {
 
-    private GraphTraversal() {
+    private PredecessorConstrainedDfs() {
         // utility class
     }
 
     /** An event emitted by the traversal: either a VISIT with an order, or a SKIP with a note. */
-    public static final class TraversalEvent<T> {
-        private final T node;
-        private final Integer order; // non-null for visit, null for skip
-        private final String note; // non-null for skip, null for visit
-
-        private TraversalEvent(T node, Integer order, String note) {
-            this.node = node;
-            this.order = order;
-            this.note = note;
+    public record TraversalEvent<T>(
+            T node,
+            Integer order, // non-null for visit, null for skip
+            String note    // non-null for skip, null for visit
+    ) {
+        public TraversalEvent {
+            Objects.requireNonNull(node);
+            // order and note can be null based on event type
         }
 
         /** A visit event with an increasing order (0,1,2,...) */
         public static <T> TraversalEvent<T> visit(T node, int order) {
-            return new TraversalEvent<>(Objects.requireNonNull(node), order, null);
+            return new TraversalEvent<>(node, order, null);
         }
 
         /** A skip event with an explanatory note (e.g., not all parents visited yet). */
         public static <T> TraversalEvent<T> skip(T node, String note) {
-            return new TraversalEvent<>(Objects.requireNonNull(node), null, Objects.requireNonNull(note));
+            return new TraversalEvent<>(node, null, Objects.requireNonNull(note));
         }
 
         public boolean isVisit() {
             return order != null;
         }
+
         public boolean isSkip() {
             return order == null;
         }
-        public T node() {
-            return node;
-        }
-        public Integer order() {
-            return order;
-        }
-        public String note() {
-            return note;
-        }
 
         @Override
         public String toString() {
-            return isVisit() ? "VISIT(" + node + ", order=" + order + ")" : "SKIP(" + node + ", " + note + ")";
+            return isVisit()
+                    ? "VISIT(" + node + ", order=" + order + ")"
+                    : "SKIP(" + node + ", " + note + ")";
         }
     }
 
@@ -118,56 +111,56 @@ public static <T> List<TraversalEvent<T>> dfsRecursiveOrder(Map<T, List<T>> succ
         return Collections.unmodifiableList(events);
     }
 
-    private static <T> void dfs(T u, Map<T, List<T>> succ, Map<T, List<T>> pred, Set<T> visited, int[] order, List<TraversalEvent<T>> out) {
+    private static <T> void dfs(T currentNode, Map<T, List<T>> successors, Map<T, List<T>> predecessors, Set<T> visited, int[] order, List<TraversalEvent<T>> result) {
 
-        if (!visited.add(u)) {
+        if (!visited.add(currentNode)) {
             return; // already visited
         }
-        out.add(TraversalEvent.visit(u, order[0]++)); // record visit and increment
+        result.add(TraversalEvent.visit(currentNode, order[0]++)); // record visit and increment
 
-        for (T v : succ.getOrDefault(u, List.of())) {
-            if (visited.contains(v)) {
+        for (T childNode : successors.getOrDefault(currentNode, List.of())) {
+            if (visited.contains(childNode)) {
                 continue;
             }
-            if (allParentsVisited(v, visited, pred)) {
-                dfs(v, succ, pred, visited, order, out);
+            if (allParentsVisited(childNode, visited, predecessors)) {
+                dfs(childNode, successors, predecessors, visited, order, result);
             } else {
-                out.add(TraversalEvent.skip(v, "⛔ Skipping " + v + ": not all parents are visited yet."));
+                result.add(TraversalEvent.skip(childNode, "⛔ Skipping " + childNode + ": not all parents are visited yet."));
                 // do not mark visited; it may be visited later from another parent
             }
         }
     }
 
-    private static <T> boolean allParentsVisited(T node, Set<T> visited, Map<T, List<T>> pred) {
-        for (T p : pred.getOrDefault(node, List.of())) {
-            if (!visited.contains(p)) {
+    private static <T> boolean allParentsVisited(T node, Set<T> visited, Map<T, List<T>> predecessors) {
+        for (T parent : predecessors.getOrDefault(node, List.of())) {
+            if (!visited.contains(parent)) {
                 return false;
             }
         }
         return true;
     }
 
-    private static <T> boolean appearsAnywhere(Map<T, List<T>> succ, T node) {
-        if (succ.containsKey(node)) {
+    private static <T> boolean appearsAnywhere(Map<T, List<T>> successors, T node) {
+        if (successors.containsKey(node)) {
             return true;
         }
-        for (List<T> nbrs : succ.values()) {
-            if (nbrs != null && nbrs.contains(node)) {
+        for (List<T> neighbours : successors.values()) {
+            if (neighbours != null && neighbours.contains(node)) {
                 return true;
             }
         }
         return false;
     }
 
-    private static <T> Map<T, List<T>> derivePredecessors(Map<T, List<T>> succ) {
-        Map<T, List<T>> pred = new HashMap<>();
+    private static <T> Map<T, List<T>> derivePredecessors(Map<T, List<T>> successors) {
+        Map<T, List<T>> predecessors = new HashMap<>();
         // ensure keys exist for all nodes appearing anywhere
-        for (Map.Entry<T, List<T>> e : succ.entrySet()) {
-            pred.computeIfAbsent(e.getKey(), k -> new ArrayList<>());
-            for (T v : e.getValue()) {
-                pred.computeIfAbsent(v, k -> new ArrayList<>()).add(e.getKey());
+        for (Map.Entry<T, List<T>> entry : successors.entrySet()) {
+            predecessors.computeIfAbsent(entry.getKey(), key -> new ArrayList<>());
+            for (T childNode : entry.getValue()) {
+                predecessors.computeIfAbsent(childNode, key -> new ArrayList<>()).add(entry.getKey());
             }
         }
-        return pred;
+        return predecessors;
     }
 }

src/test/java/com/thealgorithms/graph/GraphTraversalTest.java renamed to src/test/java/com/thealgorithms/graph/PredecessorConstrainedDfsTest.java

@@ -3,14 +3,14 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import com.thealgorithms.graph.GraphTraversal.TraversalEvent;
+import com.thealgorithms.graph.PredecessorConstrainedDfs.TraversalEvent;
 import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import org.junit.jupiter.api.Test;
 
-class GraphTraversalTest {
+class PredecessorConstrainedDfsTest {
 
     // A -> B, A -> C, B -> D, C -> D   (classic diamond)
     private static Map<String, List<String>> diamond() {
@@ -24,7 +24,7 @@ private static Map<String, List<String>> diamond() {
 
     @Test
     void dfsRecursiveOrderEmitsSkipUntilAllParentsVisited() {
-        List<TraversalEvent<String>> events = GraphTraversal.dfsRecursiveOrder(diamond(), "A");
+        List<TraversalEvent<String>> events = PredecessorConstrainedDfs.dfsRecursiveOrder(diamond(), "A");
 
         // Expect visits in order and a skip for first time we meet D (via B) before C is visited.
         var visits = events.stream().filter(TraversalEvent::isVisit).toList();
@@ -49,39 +49,39 @@ void dfsRecursiveOrderEmitsSkipUntilAllParentsVisited() {
 
     @Test
     void returnsEmptyWhenStartNotInGraph() {
-        Map<Integer, List<Integer>> g = Map.of(1, List.of(2), 2, List.of(1));
-        assertThat(GraphTraversal.dfsRecursiveOrder(g, 99)).isEmpty();
+        Map<Integer, List<Integer>> graph = Map.of(1, List.of(2), 2, List.of(1));
+        assertThat(PredecessorConstrainedDfs.dfsRecursiveOrder(graph, 99)).isEmpty();
     }
 
     @Test
     void nullSuccessorsThrows() {
-        assertThrows(IllegalArgumentException.class, () -> GraphTraversal.dfsRecursiveOrder(null, "A"));
+        assertThrows(IllegalArgumentException.class, () -> PredecessorConstrainedDfs.dfsRecursiveOrder(null, "A"));
     }
 
     @Test
     void worksWithExplicitPredecessors() {
-        Map<Integer, List<Integer>> succ = new HashMap<>();
-        succ.put(10, List.of(20));
-        succ.put(20, List.of(30));
-        succ.put(30, List.of());
+        Map<Integer, List<Integer>> successors = new HashMap<>();
+        successors.put(10, List.of(20));
+        successors.put(20, List.of(30));
+        successors.put(30, List.of());
 
-        Map<Integer, List<Integer>> pred = new HashMap<>();
-        pred.put(10, List.of());
-        pred.put(20, List.of(10));
-        pred.put(30, List.of(20));
+        Map<Integer, List<Integer>> predecessors = new HashMap<>();
+        predecessors.put(10, List.of());
+        predecessors.put(20, List.of(10));
+        predecessors.put(30, List.of(20));
 
-        var events = GraphTraversal.dfsRecursiveOrder(succ, pred, 10);
+        var events = PredecessorConstrainedDfs.dfsRecursiveOrder(successors, predecessors, 10);
         var visitNodes = events.stream().filter(TraversalEvent::isVisit).map(TraversalEvent::node).toList();
         assertThat(visitNodes).containsExactly(10, 20, 30);
     }
 
     @Test
     void cycleProducesSkipsButNoInfiniteRecursion() {
-        Map<String, List<String>> succ = new LinkedHashMap<>();
-        succ.put("X", List.of("Y"));
-        succ.put("Y", List.of("X")); // 2-cycle
+        Map<String, List<String>> successors = new LinkedHashMap<>();
+        successors.put("X", List.of("Y"));
+        successors.put("Y", List.of("X")); // 2-cycle
 
-        var events = GraphTraversal.dfsRecursiveOrder(succ, "X");
+        var events = PredecessorConstrainedDfs.dfsRecursiveOrder(successors, "X");
         // Only X is visited; encountering Y from X causes skip because Y's parent X is visited,
         // but when recursing to Y we'd hit back to X (already visited) and stop; no infinite loop.
         assertThat(events.stream().anyMatch(TraversalEvent::isVisit)).isTrue();