2050. Parallel Courses III

Solution: BFS

class Solution {
    public int minimumTime(int n, int[][] relations, int[] time) {
        int[] inDegree = new int[n + 1];
        int[] maxTimeToNode = new int[n + 1];
        
        // Build graph and inDegree table
        Map<Integer, List<Integer>> graph = new HashMap<>();
        for (int i = 1; i <= n; i++) {
            graph.put(i, new ArrayList<>());
        }
        for (int[] r : relations) {
            inDegree[r[1]]++;
            graph.get(r[0]).add(r[1]);
        }

        // inDegree = 0, course can start
        Queue<Integer> queue = new LinkedList<>();
        for (int i = 1; i <= n; i++) {
            if (inDegree[i] == 0) {
                queue.offer(i);
            }
            //in case of no adjacent course
            maxTimeToNode[i] = time[i - 1]; // i-1, since the questtion ask
        }
        
        // bfs
        while (!queue.isEmpty()) {
            int curCourse = queue.poll();
            for (int adj : graph.get(curCourse)) {
                inDegree[adj]--;
                if (inDegree[adj] == 0) {
                    queue.offer(adj);
                }
                // Update the time to reach this course (rolling update, since may have many parent course)
                maxTimeToNode[adj] = Math.max(maxTimeToNode[adj], time[adj - 1] + maxTimeToNode[curCourse]);
            }
        }

        // calculate max saperately, in case of no adjacent course
        int res = 0;
        for (int t : maxTimeToNode) {
            res = Math.max(res, t);
        }
        return res;
    }
}