[LintCode] Course Schedule

 There are a total of n courses you have to take, labeled from 0 to n - 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

Given n = 2, prerequisites = [[1,0]]
Return true

Given n = 2, prerequisites = [[1,0],[0,1]]
Return false

 

Solution 1. DFS, O(n + m) runtime

Algorithm: Detect if there is any cycle in the given graph. Keep track of vertices currently in recursion stack of method for dfs traversal. If we reach a vertext that is already in the recursion stack, it means we 

have a cycle. If a directed graph has a cycle, then it has no topological ordering.

This DFS solutions does not work well on large input as the depth of the recursive method stack will get pretty big.

version 1.

public class Solution {
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        if(prerequisites == null || prerequisites.length == 0)
        {
            return true;
        }
        ArrayList<ArrayList<Integer>> graph = new ArrayList<ArrayList<Integer>>();
        for(int i = 0; i < numCourses; i++)
        {
            graph.add(new ArrayList<Integer>());
        }
        for(int j = 0; j < prerequisites.length; j++)
        {
            graph.get(prerequisites[j][1]).add(prerequisites[j][0]);
        }
        boolean[] visited = new boolean[numCourses];
        boolean[] recursionStack = new boolean[numCourses];
        for(int i = 0; i < numCourses; i++)
        {
            visited[i] = false;
            recursionStack[i] = false;
        }
        boolean ifHasCycle = false;
        for(int node = 0; node < numCourses; node++)
        {
            if(visited[node] == false && hasCycle(node, visited, recursionStack, graph))
            {
                ifHasCycle = true;
                break;
            }
        }
        if(ifHasCycle)
        {
            return false;
        }
        return true;
    }
    private boolean hasCycle(int node, boolean[] visited, boolean[] recursionStack,
                            ArrayList<ArrayList<Integer>> graph)
    {
        if(visited[node] == false)
        {
            visited[node] = true;
            recursionStack[node] = true;
            
            for(Integer neighbor : graph.get(node))
            {
                if(visited[neighbor] == false && hasCycle(neighbor, visited, recursionStack, graph))
                {
                    return true;
                }
                else if(recursionStack[neighbor] == true)
                {
                    return true;
                }
            }
        }
        recursionStack[node] = false;
        return false;
    }
}

 

version 2.

1. construct a list of integer lists that represent a directed graph.

2. create two hash sets: a gray set that contains vertices that are being explored; a black set that contains vertices that have been completely explored. 

3. for each vertices, do a dfs and check if there is a directed cycle. 

The dfs algorithm:

1. add the current vertex to the gray set, indicating that this current vertex is being explored.

2. for each of its neighbors of this current vertex:

　　a. if it is already in the black set, skip;

　　b. if it is already in the gray set, return true to indicate there is a cycle;

　　c. otherwise, recursively call dfs on this neigbhor; if this recursive call returns true, return true;

3. after exploring all neighbors, and there is no cycle, remove the current vertex from the gray set and add it to the black set, then return false to indicate there is no cycle involving the current vertex.

    public boolean canFinish(int numCourses, int[][] prerequisites) {
        if(prerequisites == null || prerequisites.length == 0)
        {
            return true;
        }
        ArrayList<ArrayList<Integer>> graph = new ArrayList<ArrayList<Integer>>();
        for(int i = 0; i < numCourses; i++)
        {
            graph.add(new ArrayList<Integer>());
        }
        for(int j = 0; j < prerequisites.length; j++)
        {
            graph.get(prerequisites[j][1]).add(prerequisites[j][0]);
        }
        boolean isCycle = false;
        Set<Integer> graySet = new HashSet<Integer>();
        Set<Integer> blackSet = new HashSet<Integer>();
        for(int i = 0; i < numCourses; i++) {
            if(dfs(i, graySet, blackSet, graph)) {
                isCycle = true;
                break;
            }
        }
        return !isCycle;
    }
    private boolean dfs(int current, Set<Integer> graySet, Set<Integer> blackSet, 
                        ArrayList<ArrayList<Integer>> graph) {
        graySet.add(current);
        for(Integer neighbor : graph.get(current)) {
            if(blackSet.contains(neighbor)) {
                continue;
            }
            if(graySet.contains(neighbor)) {
                return true;
            }
            if(dfs(neighbor, graySet, blackSet, graph)) {
                return true;
            }
        }
        graySet.remove(current);
        blackSet.add(current);
        return false;
    }

 

Solution 2. BFS, O(n + m) runtime, O(n + m) space 

Key idea:  the starting courses must not have any dependent courses, meaning they must not have any incoming edges. When adding courses in topological order, only courses that only have incoming edges from those that have already been added to the final result should be added.

Algorithm:

1. Construct a list of integer lists as the adjacency list representation of the given graph.

2. Construct a count array that stores the number of incoming edges for each vertex.

3. Add all vertices whose incoming edges are 0 to a queue and start a bfs traversal. Keep a count of how many vertices have been explored. 

4. Each time a vertex is dequeued, conceptually cut this vertex and its outgoing edges from the graph. To do this, update its neighbors' incoming edges numbers by deducting 1. Add any neighbors whose incoming edges number becomes 0 to the queue. 

5. Repeat step 4 until the queue is empty. 

6. Check if the count is the same with the total number of vertices; If not, it means there is at least one directed cycle in the constructed graph. The vertices that are not explored are all the vertices in cycles.

    public boolean canFinish(int numCourses, int[][] prerequisites) {
        ArrayList<ArrayList<Integer>> edges = new ArrayList<ArrayList<Integer>>();
        int[] incomingEdgeNum = new int[numCourses];
        
        for(int i = 0; i < numCourses; i++)
        {
            edges.add(new ArrayList<Integer>());
        }
        int courseNum;
        for(int i = 0; i < prerequisites.length; i++)
        {
            courseNum = prerequisites[i][0];
            incomingEdgeNum[courseNum]++;
            edges.get(prerequisites[i][1]).add(prerequisites[i][0]);
        }
        
        Queue<Integer> queue = new LinkedList<Integer>();
        for(int i = 0; i < incomingEdgeNum.length; i++)
        {
            if(incomingEdgeNum[i] == 0)
            {
                queue.add(i);
            }
        }
        
        int count = 0;
        while(!queue.isEmpty())
        {
            int course = queue.poll();
            count++;
            int n = edges.get(course).size();
            for(int i = 0; i < n; i++)
            {
                int pointer = edges.get(course).get(i);
                incomingEdgeNum[pointer]--;
                if(incomingEdgeNum[pointer] == 0)
                {
                    queue.add(pointer);
                }
            }
        }
        if(count < numCourses)
        {
            return false;
        }
        return true;
    }

 

Related Problems

Course Schedule II

Topological Sorting