g0201_0300.s0210_course_schedule_ii.Solution Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of leetcode-in-java21 Show documentation
Java-based LeetCode algorithm problem solutions, regularly updated
There is a newer version: 1.38
package g0201_0300.s0210_course_schedule_ii;

// #Medium #Top_Interview_Questions #Depth_First_Search #Breadth_First_Search #Graph
// #Topological_Sort #Level_2_Day_11_Graph/BFS/DFS
// #2022_06_28_Time_13_ms_(35.17%)_Space_50.7_MB_(22.84%)

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 210 - Course Schedule II\.
 *
 * Medium
 *
 * There are a total of `numCourses` courses you have to take, labeled from `0` to `numCourses - 1`. You are given an array `prerequisites` where prerequisites[i] = [a_i, b_i] indicates that you **must** take course b_i first if you want to take course a_i.
 *
 * *   For example, the pair `[0, 1]`, indicates that to take course `0` you have to first take course `1`.
 *
 * Return _the ordering of courses you should take to finish all courses_. If there are many valid answers, return **any** of them. If it is impossible to finish all courses, return **an empty array**.
 *
 * **Example 1:**
 *
 * **Input:** numCourses = 2, prerequisites = \[\[1,0]]
 *
 * **Output:** [0,1]
 *
 * **Explanation:**
 *
 *     There are a total of 2 courses to take. To take course 1 you should have finished course 0.
 *     So the correct course order is [0,1].
 *
 * **Example 2:**
 *
 * **Input:** numCourses = 4, prerequisites = \[\[1,0],[2,0],[3,1],[3,2]]
 *
 * **Output:** [0,2,1,3]
 *
 * **Explanation:**
 *
 *     There are a total of 4 courses to take. To take course 3 you should have finished both courses 1 and 2. Both courses 1 and 2 should be taken after you finished course 0.
 *     So one correct course order is [0,1,2,3]. Another correct ordering is [0,2,1,3].
 *
 * **Example 3:**
 *
 * **Input:** numCourses = 1, prerequisites = []
 *
 * **Output:** [0] 
 *
 * **Constraints:**
 *
 * *   `1 <= numCourses <= 2000`
 * *   `0 <= prerequisites.length <= numCourses * (numCourses - 1)`
 * *   `prerequisites[i].length == 2`
 * *   0 <= a_i, b_i < numCourses
 * *   a_i != b_i
 * *   All the pairs [a_i, b_i] are **distinct**.
**/
public class Solution {
    public int[] findOrder(int numCourses, int[][] prerequisites) {
        Map> graph = new HashMap<>();
        for (int i = 0; i < numCourses; i++) {
            graph.put(i, new ArrayList<>());
        }
        for (int[] classes : prerequisites) {
            graph.get(classes[0]).add(classes[1]);
        }
        List output = new ArrayList<>();
        Map visited = new HashMap<>();
        for (int c : graph.keySet()) {
            if (dfs(c, graph, visited, output)) {
                return new int[0];
            }
        }
        int[] res = new int[output.size()];
        for (int i = 0; i < output.size(); i++) {
            res[i] = output.get(i);
        }
        return res;
    }

    private boolean dfs(
            int course,
            Map> graph,
            Map visited,
            List output) {
        if (visited.containsKey(course)) {
            return visited.get(course);
        }
        visited.put(course, true);
        for (int c : graph.get(course)) {
            if (dfs(c, graph, visited, output)) {
                return true;
            }
        }
        visited.put(course, false);
        output.add(course);
        return false;
    }
}