304 North Cardinal St.
Dorchester Center, MA 02124

# Course Schedule II LeetCode Solution – Queslers

### Problem – Course Schedule II

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] = [ai, bi]` indicates that you must take course `bi` first if you want to take course `ai`.

• 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: ``````

Constraints:

• `1 <= numCourses <= 2000`
• `0 <= prerequisites.length <= numCourses * (numCourses - 1)`
• `prerequisites[i].length == 2`
• `0 <= ai, bi < numCourses`
• `ai != bi`
• All the pairs `[ai, bi]` are distinct.

### Course Schedule II LeetCode Solution in Java

``````private int[] solveByDFS(List<List<Integer>> adjs) {
BitSet hasCycle = new BitSet(1);
BitSet visited = new BitSet(adjs.size());
BitSet onStack = new BitSet(adjs.size());
Deque<Integer> order = new ArrayDeque<>();
for (int i = adjs.size() - 1; i >= 0; i--) {
if (visited.get(i) == false && hasOrder(i, adjs, visited, onStack, order) == false) return new int;
}
int[] orderArray = new int[adjs.size()];
for (int i = 0; !order.isEmpty(); i++) orderArray[i] = order.pop();
return orderArray;
}

private boolean hasOrder(int from, List<List<Integer>> adjs, BitSet visited, BitSet onStack, Deque<Integer> order) {
visited.set(from);
onStack.set(from);
for (int to : adjs.get(from)) {
if (visited.get(to) == false) {
if (hasOrder(to, adjs, visited, onStack, order) == false) return false;
} else if (onStack.get(to) == true) {
return false;
}
}
onStack.clear(from);
order.push(from);
return true;
}
``````

### Course Schedule II LeetCode Solution in C++

``````class Solution {
public:
vector<int> findOrder(int numCourses, vector<pair<int, int>>& prerequisites) {
graph g = buildGraph(numCourses, prerequisites);
vector<int> degrees = computeIndegrees(g);
vector<int> order;
for (int i = 0; i < numCourses; i++) {
int j = 0;
for (; j < numCourses; j++) {
if (!degrees[j]) {
order.push_back(j);
break;
}
}
if (j == numCourses) {
return {};
}
degrees[j]--;
for (int v : g[j]) {
degrees[v]--;
}
}
return order;
}
private:
typedef vector<vector<int>> graph;

graph buildGraph(int numCourses, vector<pair<int, int>>& prerequisites) {
graph g(numCourses);
for (auto p : prerequisites) {
g[p.second].push_back(p.first);
}
return g;
}

vector<int> computeIndegrees(graph& g) {
vector<int> degrees(g.size(), 0);
for (auto adj : g) {
for (int v : adj) {
degrees[v]++;
}
}
return degrees;
}
};
``````

### Course Schedule II LeetCode Solution in Python

``````class Solution:
# @param {integer} numCourses
# @param {integer[][]} prerequisites
# @return {integer[]}
def findOrder(self, numCourses, prerequisites):
# use DFS to parse the course structure
self.graph = collections.defaultdict(list) # a graph for all courses
self.res = [] # start from empty
for pair in prerequisites:
self.graph[pair].append(pair)
self.visited = [0 for x in xrange(numCourses)] # DAG detection
for x in xrange(numCourses):
if not self.DFS(x):
return []
# continue to search the whole graph
return self.res

def DFS(self, node):
if self.visited[node] == -1: # cycle detected
return False
if self.visited[node] == 1:
return True # has been finished, and been added to self.res
self.visited[node] = -1 # mark as visited
for x in self.graph[node]:
if not self.DFS(x):
return False
self.visited[node] = 1 # mark as finished
self.res.append(node) # add to solution as the course depenedent on previous ones
return True``````
##### Course Schedule II LeetCode Solution Review:

In our experience, we suggest you solve this Course Schedule II LeetCode Solution and gain some new skills from Professionals completely free and we assure you will be worth it.

If you are stuck anywhere between any coding problem, just visit Queslers to get the Course Schedule II LeetCode Solution

Find on LeetCode

##### Conclusion:

I hope this Course Schedule II LeetCode Solution would be useful for you to learn something new from this problem. If it helped you then don’t forget to bookmark our site for more Coding Solutions.

This Problem is intended for audiences of all experiences who are interested in learning about Data Science in a business context; there are no prerequisites.

Keep Learning!

More Coding Solutions >>

LeetCode Solutions

Hacker Rank Solutions

CodeChef Solutions