剑指 Offer II 113. 课程顺序
comments: true
edit_url: https://github.com/doocs/leetcode/edit/main/lcof2/%E5%89%91%E6%8C%87%20Offer%20II%20113.%20%E8%AF%BE%E7%A8%8B%E9%A1%BA%E5%BA%8F/README.md
剑指 Offer II 113. 课程顺序
题目描述
现在总共有 numCourses 门课需要选，记为 0 到 numCourses-1。
给定一个数组 prerequisites ，它的每一个元素 prerequisites[i] 表示两门课程之间的先修顺序。 例如 prerequisites[i] = [ai, bi] 表示想要学习课程 ai ，需要先完成课程 bi 。
请根据给出的总课程数 numCourses 和表示先修顺序的 prerequisites 得出一个可行的修课序列。
可能会有多个正确的顺序，只要任意返回一种就可以了。如果不可能完成所有课程，返回一个空数组。
示例 1:
输入: numCourses = 2, prerequisites = [[1,0]] 输出:[0,1]解释: 总共有 2 门课程。要学习课程 1，你需要先完成课程 0。因此，正确的课程顺序为[0,1] 。
示例 2:
输入: numCourses = 4, prerequisites = [[1,0],[2,0],[3,1],[3,2]] 输出:[0,1,2,3] or [0,2,1,3]解释: 总共有 4 门课程。要学习课程 3，你应该先完成课程 1 和课程 2。并且课程 1 和课程 2 都应该排在课程 0 之后。 因此，一个正确的课程顺序是[0,1,2,3]。另一个正确的排序是[0,2,1,3]。
示例 3:
输入: numCourses = 1, prerequisites = []
输出: [0]
解释: 总共 1 门课，直接修第一门课就可。
提示:
1 <= numCourses <= 20000 <= prerequisites.length <= numCourses * (numCourses - 1)prerequisites[i].length == 20 <= ai, bi < numCoursesai != biprerequisites中不存在重复元素
注意：本题与主站 210 题相同：https://leetcode.cn/problems/course-schedule-ii/
解法
方法一：拓扑排序
拓扑排序的思路是，先统计每个节点的入度，然后从入度为 0 的节点开始，依次删除这些节点，同时更新与这些节点相连的节点的入度，直到所有节点都被删除。
这里使用队列来存储入度为 0 的节点，每次从队列中取出一个节点，将其加入结果数组中，然后遍历与这个节点相连的节点，将这些节点的入度减 1，如果减 1 后入度为 0，则将这些节点加入队列中。
最后判断结果数组的长度是否等于节点的个数，如果等于则返回结果数组，否则返回空数组。
时间复杂度 O ( n + m ) O(n + m) O(n+m)，空间复杂度 O ( n + m ) O(n + m) O(n+m)。其中 n n n 和 m m m 分别是节点的个数和边的个数。
Python3
class Solution:
def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
graph=defaultdict(list)
indg={} #其实目的还是为bfs第一层服务的
for i in range(numCourses): #【注意】初始化，要不然第一层为空
indg[i]=0
for b,a in prerequisites:
graph[a].append(b)
indg[b]+=1
# 第一层
q=deque()
for node,ind in indg.items():
if ind==0:q.append(node)
print(q,indg)
#bfs
res=[]
while q:
for _ in range(len(q)):
cur=q.popleft()
res.append(cur)
for nx in graph[cur]:
indg[nx]-=1
if indg[nx]==0:
q.append(nx)
return res if len(res)==numCourses else []
Java
class Solution {
public int[] findOrder(int numCourses, int[][] prerequisites) {
List<Integer>[] g = new List[numCourses];
Arrays.setAll(g, k -> new ArrayList<>());
int[] indeg = new int[numCourses];
for (var p : prerequisites) {
int a = p[0], b = p[1];
g[b].add(a);
++indeg[a];
}
Deque<Integer> q = new ArrayDeque<>();
for (int i = 0; i < numCourses; ++i) {
if (indeg[i] == 0) {
q.offer(i);
}
}
int[] ans = new int[numCourses];
int cnt = 0;
while (!q.isEmpty()) {
int i = q.poll();
ans[cnt++] = i;
for (int j : g[i]) {
if (--indeg[j] == 0) {
q.offer(j);
}
}
}
return cnt == numCourses ? ans : new int[0];
}
}
C++
class Solution {
public:
vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
vector<int> g[numCourses];
vector<int> indeg(numCourses);
for (auto& p : prerequisites) {
int a = p[0], b = p[1];
g[b].push_back(a);
++indeg[a];
}
queue<int> q;
for (int i = 0; i < numCourses; ++i) {
if (indeg[i] == 0) {
q.push(i);
}
}
vector<int> ans;
while (q.size()) {
int i = q.front();
q.pop();
ans.push_back(i);
for (int j : g[i]) {
if (--indeg[j] == 0) {
q.push(j);
}
}
}
return ans.size() == numCourses ? ans : vector<int>();
}
};
Go
func findOrder(numCourses int, prerequisites [][]int) []int {
g := make([][]int, numCourses)
indeg := make([]int, numCourses)
for _, p := range prerequisites {
a, b := p[0], p[1]
g[b] = append(g[b], a)
indeg[a]++
}
q := []int{}
for i, v := range indeg {
if v == 0 {
q = append(q, i)
}
}
ans := []int{}
for len(q) > 0 {
i := q[0]
q = q[1:]
ans = append(ans, i)
for _, j := range g[i] {
indeg[j]--
if indeg[j] == 0 {
q = append(q, j)
}
}
}
if len(ans) == numCourses {
return ans
}
return []int{}
}
TypeScript
function findOrder(numCourses: number, prerequisites: number[][]): number[] {
const g: number[][] = Array.from({ length: numCourses }, () => []);
const indeg: number[] = Array(numCourses).fill(0);
for (const [a, b] of prerequisites) {
g[b].push(a);
++indeg[a];
}
const q: number[] = indeg.map((v, i) => (v === 0 ? i : -1)).filter(v => v !== -1);
const ans: number[] = [];
while (q.length) {
const i = q.pop()!;
ans.push(i);
for (const j of g[i]) {
if (--indeg[j] === 0) {
q.push(j);
}
}
}
return ans.length === numCourses ? ans : [];
}
C#
public class Solution {
public int[] FindOrder(int numCourses, int[][] prerequisites) {
List<int>[] g = new List<int>[numCourses];
for (int i = 0; i < numCourses; i++) {
g[i] = new List<int>();
}
int[] indeg = new int[numCourses];
foreach (var p in prerequisites) {
int a = p[0], b = p[1];
g[b].Add(a);
++indeg[a];
}
Queue<int> q = new Queue<int>();
for (int i = 0; i < numCourses; ++i) {
if (indeg[i] == 0) {
q.Enqueue(i);
}
}
int[] ans = new int[numCourses];
int cnt = 0;
while (q.Count > 0) {
int i = q.Dequeue();
ans[cnt++] = i;
foreach (int j in g[i]) {
if (--indeg[j] == 0) {
q.Enqueue(j);
}
}
}
return cnt == numCourses ? ans : new int[0];
}
}
Swift
class Solution {
func findOrder(_ numCourses: Int, _ prerequisites: [[Int]]) -> [Int] {
var graph = Array(repeating: [Int](), count: numCourses)
var indegree = Array(repeating: 0, count: numCourses)
for prereq in prerequisites {
let course = prereq[0]
let prereqCourse = prereq[1]
graph[prereqCourse].append(course)
indegree[course] += 1
}
var queue = [Int]()
for i in 0..<numCourses {
if indegree[i] == 0 {
queue.append(i)
}
}
var order = [Int]()
while !queue.isEmpty {
let course = queue.removeFirst()
order.append(course)
for nextCourse in graph[course] {
indegree[nextCourse] -= 1
if indegree[nextCourse] == 0 {
queue.append(nextCourse)
}
}
}
return order.count == numCourses ? order : []
}
}