Baozi Training Leetcode solution 207. Course Schedule

Problem Statement 

There are a total of numCourses courses you have to take, labeled from 0 to numCourses-1.

Some courses may have prerequisites, for example to take course 0 you have to first take course 1, which is expressed as a pair: [0,1]

Given the total number of courses and a list of prerequisite pairs, is it possible for you to finish all courses?

 

Example 1:

Input: numCourses = 2, prerequisites = [[1,0]]
Output: true
Explanation: There are a total of 2 courses to take. 
             To take course 1 you should have finished course 0. So it is possible.

Example 2:

Input: numCourses = 2, prerequisites = [[1,0],[0,1]]
Output: false
Explanation: There are a total of 2 courses to take. 
             To take course 1 you should have finished course 0, and to take course 0 you should
             also have finished course 1. So it is impossible.

 

Constraints:

• The input prerequisites is a graph represented by a list of edges, not adjacency matrices. Read more about how a graph is represented.
• You may assume that there are no duplicate edges in the input prerequisites.
• 1 <= numCourses <= 10^5

 Problem link

Video Tutorial

You can find the detailed video tutorial here

• Youtube
• Youtube BFS in 2015, Youtube DFS in 2015
• B站

Thought Process

It is a classic dependency graph problem. We can translate this problem to direct if there is a cycle in a directed graph or not. A text book solution is Kahn's algorithm for topological sorting. We can have a simple way to represent the graph or use a more proper adjacency lists (a little bit overkill for this problem though)

Solutions 

Use adjacency lists BFS

private class Node {
    public int val;
    public List<Node> neighbors;

    public Node(int val) {
        this.val = val;
        this.neighbors = new ArrayList<>();
    }
}

private List<Node> buildGraph(int num, int[][] prerequisites) {
    List<Node> graph = new ArrayList<>();

    for (int i = 0; i < num; i++) {
        graph.add(new Node(i));
    }

    for (int i = 0; i < prerequisites.length; i++) {
        graph.get(prerequisites[i][0]).neighbors.add(graph.get(prerequisites[i][1]));
    }

    return graph;
}

// model to a Nodes, still BFS with topological order to detect if a graph is a DAG
// https://www.geeksforgeeks.org/detect-cycle-in-a-directed-graph-using-bfs/
public boolean canFinishGraph(int numCourses, int[][] prerequisites) {
    if (numCourses <= 1 || prerequisites.length == 0 || prerequisites[0].length == 0) {
        return true;
    }
    List<Node> graph = this.buildGraph(numCourses, prerequisites);

    Queue<Node> q = new LinkedList<>();

    for (Node n : graph) {
        if (n.neighbors.size() == 0) {
            q.add(n);
        }
    }

    Set<Node> visited = new HashSet<>();
    while (!q.isEmpty()) {
        Node cur = q.poll();

        visited.add(cur);

        for (Node n : graph) {
            if (n.neighbors.contains(cur)) {
                n.neighbors.remove(cur);
                // only enqueue the nodes while there is no more neighbors
                if (n.neighbors.size() == 0) {
                    q.add(n);
                }
            }
        }

    }

    return visited.size() == numCourses;
}
@shixiaoyu
 

 

Time Complexity: O(V), since each vertex is visited only once during BFS
Space Complexity: O(V+E) since we use adjacency lists to represent a directed graph

Use simple hashmap BFS

public boolean canFinishBfsTopoSort(int numCourses, int[][] prerequisites) {
    if (numCourses <= 1 || prerequisites.length == 0 || prerequisites[0].length == 0) {
        return true;
    }

    Map<Integer, Set<Integer>> graph = new HashMap<>();

    // could be extracted into a build graph function
    for (int i = 0; i < numCourses; i++) {
        graph.put(i, new HashSet<>());
    }

    for (int i = 0; i < prerequisites.length; i++) {
        graph.get(prerequisites[i][0]).add(prerequisites[i][1]);
    }

    int coursesRemaining = numCourses;
    Queue<Integer> queue = new LinkedList<>();

    // initialize
    for (Map.Entry<Integer, Set<Integer>> entry : graph.entrySet()) {
        // this is the reverse as the graph topological order, but it is the actual problem solving order
        // e.g., a->b, -> reads as depends on, meaning you have to finish b to do a, so it will print out b, a
        if (entry.getValue().size() == 0) { 
            queue.offer(entry.getKey());
            coursesRemaining--;
        }
    }

    // BFS
    while (!queue.isEmpty()) {
        int key = queue.poll();
        System.out.println("** key: " + key);
        for (Map.Entry<Integer, Set<Integer>> entry : graph.entrySet()) {
            Set<Integer> curDependencies = entry.getValue();

            if (curDependencies.contains(key)) {
                curDependencies.remove((Integer)key); // need to cast or else it will be remove(int index)
                if (curDependencies.size() == 0) { // immediately check to avoid another loop
                    queue.offer(entry.getKey());
                    coursesRemaining--;
                }
            }
        }
    }

    return coursesRemaining == 0;
}

 

Time Complexity: O(V), since each vertex is visited only once during BFS

Space Complexity: O(V) since we are using a hashmap

 

Use recursion DFS

// This is a DFS solution, basically just like detecting if a graph has loops.
// Used a lookup table prune, with lookup, this is O(V + E), same as BFS since each node is visited once and only once
public boolean canFinish(int numCourses, int[][] prerequisites) {
    if (numCourses <= 1 || prerequisites.length == 0 || prerequisites[0].length == 0) {
        return true;
    }

    // this is adjacency list, used a set to dedup
    Map<Integer, Set<Integer>> graph = new HashMap<>();

    for (int i = 0; i < numCourses; i++) {
        graph.put(i, new HashSet<>());
    }

    for (int i = 0; i < prerequisites.length; i++) {
        graph.get(prerequisites[i][0]).add(prerequisites[i][1]);
    }

    Map<Integer, Boolean> lookup = new HashMap<>();

    boolean[] visited = new boolean[numCourses];
    for (int i = 0; i < numCourses; i++) {
        if (!this.explore(i, graph, visited, lookup)) {
            return false;
        }
    }
    return true;
}

// This is the DFS way to solve it, This could also generate a topological order, think about post order way
// return false if there is a loop, true if no loop
private boolean explore(int vertex, Map<Integer, Set<Integer>> graph, boolean[] visited, Map<Integer, Boolean> lookup) {
    // keeps track of if the node has been visited or not, 
    // with this lookup, it's pruning (memorization so that we don't need to re-calculate previously visited node)
    /*
           1
         /    \
       0       3  - 4
         \ 2  /
      e.g., when recursion 0 -> 1 -> 3 -> 4
                 in 2nd round, 0 -> 2 -> 3(could directly return) 
     */
    if (lookup.containsKey(vertex)) {  
        return lookup.get(vertex);
    }

    visited[vertex] = true; // keeps track of visited or not during recursion

    Set<Integer> dependencies = graph.get(vertex);
    for (Integer i : dependencies) {
        if (visited[i] || !this.explore(i, graph, visited, lookup)) {
            return false;
        }
    }
    visited[vertex] = false;
    lookup.put(vertex, true);
    return true;
}

 

Time Complexity: O(V), since each vertex is visited only once during BFS

Space Complexity: O(V) since we used a lookup hashmap for memorization purpose (not considering function stack space)

 

References

• Leetcode official solution
• GeeksforGeeks Detect Cycle in a directly graph using topological sort