## Description

https://leetcode.com/problems/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] = [a`

indicates that you _{i}, b_{i}]**must** take course `b`

first if you want to take course _{i}`a`

._{i}

- 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:[0]

**Constraints:**

`1 <= numCourses <= 2000`

`0 <= prerequisites.length <= numCourses * (numCourses - 1)`

`prerequisites[i].length == 2`

`0 <= a`

_{i}, b_{i}< numCourses`a`

_{i}!= b_{i}- All the pairs
`[a`

are_{i}, b_{i}]**distinct**.

## Explanation

Similar to the problem Course Schedule I, we can use topological sort to solve this problem. Base on the indegree values for the courses to find out the result.

## Python Solution

```
class Solution:
def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
results = []
adjacent_list = []
indegrees = []
for i in range(numCourses):
adjacent_list.append([])
indegrees.append(0)
for prerequisite in prerequisites:
adjacent_list[prerequisite[1]].append(prerequisite[0])
indegrees[prerequisite[0]] += 1
queue = []
for i, indegree in enumerate(indegrees):
if indegree == 0:
queue.append(i)
while queue:
course = queue.pop(0)
results.append(course)
for adj_course in adjacent_list[course]:
indegrees[adj_course] -= 1
if indegrees[adj_course] == 0:
queue.append(adj_course)
if len(results) < numCourses:
return []
return results
```

- Time Complexity: ~V + E
- Space Complexity: ~V + E

where V is the number of courses, and E is the number of prerequisites.