solves #1136: Parallel courses in java

Author: anishLearnsToCode

README.md

@@ -517,6 +517,7 @@
 | 1128 | [Number of Equivalent Domino Pairs](https://leetcode.com/problems/number-of-equivalent-domino-pairs)                                                                   |                                                                                [![Java](assets/java.png)](src/NumberOfEquivalentDominoPairs.java)                                                                                |                                                                                                                                   |
 | 1133 | 🔒 [Largest Unique Number](https://leetcode.com/problems/largest-unique-number)                                                                                        |                                                                                                                                                                                                                                  |                                                                                                                                   |
 | 1134 | 🔒 [Armstrong Number](https://leetcode.com/problems/armstrong-number)                                                                                                  |                                                                                                                                                                                                                                  |                                                                                                                                   |
+| 1136 | 🔒 [Parallel Courses](https://leetcode.com/problems/parallel-courses)                                                                                                  |                                                                                       [![Java](assets/java.png)](src/ParallelCourses.java)                                                                                       |                                                                                                                                   |
 | 1137 | [Nth Tribonacci Number](https://leetcode.com/problems/n-th-tribonacci-number)                                                                                          |                                                                                     [![Java](assets/java.png)](src/NthTribonacciNumber.java)                                                                                     |                                                                                                                                   |
 | 1143 | [Longest Common Subsequence](https://leetcode.com/problems/longest-common-subsequence)                                                                                 |                                                                                  [![Java](assets/java.png)](src/LongestCommonSubsequence.java)                                                                                   |                                                                                                                                   |
 | 1150 | [Check if Number is Majority Element in Sorted Array](https://leetcode.com/problems/check-if-a-number-is-majority-element-in-a-sorted-array)                           |                                                                                                                                                                                                                                  |                                                                                                                                   |

src/ParallelCourses.java

@@ -0,0 +1,73 @@
+// https://leetcode.com/problems/parallel-courses
+// T: O(N + E)
+// S: O(N + E)
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+public class ParallelCourses {
+    public int minimumSemesters(int n, int[][] relations) {
+        final Map<Integer, Set<Integer>> graph = createGraph(relations);
+        final int[] inDegree = computeInDegree(relations, n);
+        return minimumSemesters(graph, inDegree);
+    }
+
+    // Kahn's algorithm T: O(N + E), S: O(N)
+    private static int minimumSemesters(Map<Integer, Set<Integer>> graph, int[] inDegree) {
+        Set<Integer> noPrerequisites = coursesWithoutPrerequisites(inDegree);
+        int minSemesters = 0;
+
+        while (!noPrerequisites.isEmpty()) {
+            final Set<Integer> newCourses = new HashSet<>();
+            for (int course : noPrerequisites) {
+                inDegree[course]--;
+                for (int neighbour : graph.getOrDefault(course, new HashSet<>())) {
+                    inDegree[neighbour]--;
+                    if (inDegree[neighbour] == 0) {
+                        newCourses.add(neighbour);
+                    }
+                }
+                graph.remove(course);
+            }
+            noPrerequisites = newCourses;
+            minSemesters++;
+        }
+
+        return graph.isEmpty() ? minSemesters : -1;
+    }
+
+    // T: O(E), S: O(N)
+    private static int[] computeInDegree(int[][] edges, int n) {
+        final int[] inDegree = new int[n];
+        for (int[] edge : edges) {
+            final int to = edge[1] - 1;
+            inDegree[to]++;
+        }
+        return inDegree;
+    }
+
+    // T: O(N), S: O(N)
+    private static Set<Integer> coursesWithoutPrerequisites(int[] inDegree) {
+        final Set<Integer> set = new HashSet<>();
+        for (int i = 0 ; i < inDegree.length ; i++) {
+            if (inDegree[i] == 0) {
+                set.add(i);
+            }
+        }
+        return set;
+    }
+
+    // T: O(E), S: O(E)
+    private static Map<Integer, Set<Integer>> createGraph(int[][] edges) {
+        final Map<Integer, Set<Integer>> graph = new HashMap<>();
+        for (int[] edge : edges) {
+            final int from = edge[0] - 1, to = edge[1] - 1;
+            final Set<Integer> fromNeighbours = graph.getOrDefault(from, new HashSet<>());
+            fromNeighbours.add(to);
+            graph.putIfAbsent(from, fromNeighbours);
+        }
+        return graph;
+    }
+}