leetcode【210】【Depth-first Search】Course Schedule II【c++版本】

本文链接：https://blog.csdn.net/fanyuwgy/article/details/111165435

本文介绍了一种基于图的课程排序算法，用于确定完成一系列带有前置条件的课程的学习顺序。通过构建图结构并使用队列实现拓扑排序，可以有效判断课程间依赖关系是否形成闭环。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

问题描述：

There are a total of n courses you have to take labelled from 0 to n - 1.

Some courses may have prerequisites, for example, if prerequisites[i] = [ai, bi] this means you must take the course bi before the course ai.

Given the total number of courses numCourses and a list of the prerequisite pairs, 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]

源码：

和上一题比较像leetcode【207】【Depth-first Search】Course Schedule【c++版本】，不过这一题需要找到序列，当然也可以用上一题类似的做法，但是在这里我们考虑用一个队列解决。

我们先为所有节点建立一个图graph，并且计算他们的入度indegree；
将入度为0的点放入队列points；
拿出队首元素添加到result，将其相邻的节点入度减一，再次将入度为0的节点放入队列，重复多次直至队列为空；
result的长度是否等于节点个数numCourses，若不等于则说明没有遍历完，即存在环，返回空result；否则返回result。

class Solution {
public:
    vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
        vector<int> result;
        vector<vector<int>> graph (numCourses, vector<int> (numCourses, 0));
        vector<int> indegree(numCourses, 0);
        queue<int> points;
        for (int i=0; i<prerequisites.size(); i++) {
            graph[prerequisites[i][1]][prerequisites[i][0]] = 1;
            indegree[prerequisites[i][0]]++;
        }
        for (int i=0; i<numCourses; i++) {
            if (indegree[i] == 0) {
                points.push(i);
            }
        }
        
        while (!points.empty()) {
            int tmp = points.front();
            points.pop();
            result.push_back(tmp);
            for (int i=0; i<numCourses; i++) {
                if(graph[tmp][i] && --indegree[i] == 0) {
                    points.push(i);
                }
            }
        }
        if (result.size() != numCourses) {
            return vector<int> ();
        }
        return result;
    }
};