Course Schedule 解答

Question

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?

For example:

2, [[1,0]]

There are a total of 2 courses to take. To take course 1 you should have finished course 0. So it is possible.

2, [[1,0],[0,1]]

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.

Solution 1 -- DFS

This question can be transferred to judge whether the graph has cycle.

There are two key points for this question.

1. How to construct adjacency list according to edge lists? (Graph representation)

Usually, we use ArrayList[] to represent adjacency list.

2. How to use DFS to judge whether the graph has cycle. This solution can be further modified to implement topological sort.

Time complexity O(|V| + |E|)

 public class Solution {
     public boolean canFinish(int numCourses, int[][] prerequisites) {
         if (prerequisites == null || prerequisites.length == 0)
             return true;
         // Construct adjacency list
         ArrayList<Integer>[] adjacencyList = new ArrayList[numCourses];
         for (int i = 0; i < numCourses; i++) {
             ArrayList<Integer> tmpList = new ArrayList<Integer>();
             tmpList.add(i);
             adjacencyList[i] = tmpList;
         }
         for (int i = 0; i < prerequisites.length; i++) {
             int[] currentPair = prerequisites[i];
             adjacencyList[currentPair[0]].add(currentPair[1]);
         }

         // DFS Because we need to judge whether the graph has cycle, we use three status for each node
         // 0 -> not start; 1 -> start dfs, but not complete; 2 -> complete dfs;
         short[] used = new short[numCourses];
         for (int i = 0; i < numCourses; i++) {
             if (used[i] == 0) {
                 boolean result = dfs(adjacencyList, used, i);
                 if (!result)
                     return false;
             }
         }
         return true;
     }

     private boolean dfs(ArrayList<Integer>[] graph, short[] used, int i) {
         used[i] = 1;
         ArrayList<Integer> neighbor = graph[i];
         for (int j = 1; j < neighbor.size(); j++) {
             int index = neighbor.get(j);
             if (used[index] == 1)
                 return false;
             if (used[index] == 2)
                 continue;
             if (used[index] == 0) {
                 if (!dfs(graph, used, index))
                     return false;
             }
         }
         used[i] = 2;
         return true;
     }

 }

Solution 2

We adopt second way to implement topological sort.

We maintain a queue to store vertices whose in-degree is 0. Time complexity O(|V| + |E|).

 public class Solution {
     public boolean canFinish(int numCourses, int[][] prerequisites) {
         if (prerequisites == null || prerequisites.length == 0)
             return true;
         // Construct adjacency list
         ArrayList<Integer>[] adjacencyList = new ArrayList[numCourses];
         for (int i = 0; i < numCourses; i++) {
             ArrayList<Integer> tmpList = new ArrayList<Integer>();
             tmpList.add(i);
             adjacencyList[i] = tmpList;
         }
         for (int i = 0; i < prerequisites.length; i++) {
             int[] currentPair = prerequisites[i];
             adjacencyList[currentPair[0]].add(currentPair[1]);
         }
         // Maintain a queue to store vertices with in-degree is 0
         Queue<Integer> queue = new LinkedList<Integer>();
         int[] inDegree = new int[numCourses];
         Arrays.fill(inDegree, 0);
         // Initialize in-degree array
         for (ArrayList<Integer> tmpList : adjacencyList) {
             int size = tmpList.size();
             for (int i = 1; i < size; i++)
                 inDegree[tmpList.get(i)]++;
         }
         // Initialize queue
         for (int i = 0; i < numCourses; i++) {
             if (inDegree[i] == 0)
                 queue.add(i);
         }
         if (queue.size() == 0)
             return false;
         int count = 0;
         while (queue.size() > 0) {
             int key = queue.remove();
             ArrayList<Integer> neighbor = adjacencyList[key];
             for (int i = 1; i < neighbor.size(); i++) {
                 int tmp = neighbor.get(i);
                 inDegree[tmp]--;
                 if (inDegree[tmp] == 0) {
                     queue.add(tmp);
                 }
             }
             count++;
         }
         return count == numCourses;
     }
 }