[LintCode] Course Schedule II

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, return the ordering of courses you should take to finish all courses.

There may be multiple correct orders, you just need to return one of them. If it is impossible to finish all courses, return an empty array.

 

Example

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

Given n = 4, prerequisites = [1,0],[2,0],[3,1],[3,2]]
Return [0,1,2,3] or [0,2,1,3]

 

This problem is essentially the same with Course Schedule. The only difference is that this problem asks for a concrete topological ordering.

We can leverage the solutions from Topological Sorting and solve this problem using both BFS and DFS. The difference here would be cycle detection logic since it is not guranteed that we can find a topological ordering.

 

Solution 1. BFS 

public class Solution {
    /**
     * @param numCourses a total of n courses
     * @param prerequisites a list of prerequisite pairs
     * @return the course order
     */
    public int[] findOrder(int numCourses, int[][] prerequisites) {
        ArrayList<ArrayList<Integer>> edges = new ArrayList<ArrayList<Integer>>();
        int[] incomingEdgeNum = new int[numCourses];
        int[] result = 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(courseNum);
        }
        
        Queue<Integer> queue = new LinkedList<Integer>();
        int currIdx = 0;
        for(int i = 0; i < incomingEdgeNum.length; i++)
        {
            if(incomingEdgeNum[i] == 0)
            {
                queue.add(i);
                result[currIdx] = i;
                currIdx++;
            }
        }
        
        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 neighbor = edges.get(course).get(i);
                incomingEdgeNum[neighbor]--;
                if(incomingEdgeNum[neighbor] == 0)
                {
                    queue.add(neighbor);
                    result[currIdx] = neighbor;
                    currIdx++;
                }
            }
        }
        if(count < numCourses)
        {
            return new int[0];
        }
        return result;
    }
}

 

Solution 2.DFS 

The depth of the recursive calls can get big if the input size gets big.

 

public class Solution {
    public int[] findOrder(int numCourses, int[][] prerequisites) {
        if(numCourses <= 0) {
            return new int[0];
        }
        if(prerequisites == null) {
            int[] result = new int[numCourses];
            for(int i = 0; i < numCourses; i++) {
                result[i] = i;
            }
            return result;
        }
        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 hasCycle = false;
        Set<Integer> exploring = new HashSet<Integer>();
        Set<Integer> explored = new HashSet<Integer>();
        Stack<Integer> stack = new Stack<Integer>();
        int[] result = new int[numCourses];
        for(int i = 0; i < numCourses; i++) {
            if(!explored.contains(i) && dfs(i, exploring, explored, graph, stack)) {
                hasCycle = true;
                break;
            }
        }
        if(hasCycle) {
            return new int[0];
        }
        int idx = 0;
        while(!stack.empty()) {
            result[idx] = stack.pop();
            idx++;
        }
        return result;
    }
    private boolean dfs(int current, Set<Integer> exploring, Set<Integer> explored,
                        ArrayList<ArrayList<Integer>> graph, Stack<Integer> stack) {
        exploring.add(current);
        for(Integer neighbor : graph.get(current)) {
            if(explored.contains(neighbor)) {
                continue;
            }
            if(exploring.contains(neighbor)) {
                return true;
            }
            if(dfs(neighbor, exploring, explored, graph, stack)) {
                return true;
            }
        }
        exploring.remove(current);
        explored.add(current);
        stack.push(current);
        return false;
    } 
}

 

 

Related Problems

Course Schedule

Sequence Reconstruction

Topological Sorting