题目: 207. 课程表

你这个学期必须选修 numCourse 门课程，记为 0 到 numCourse-1 。

在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们：[0,1]

给定课程总量以及它们的先决条件，请你判断是否可能完成所有课程的学习？

示例 1:
输入: 2, [[1,0]]
输出: true
解释: 总共有 2 门课程。学习课程 1 之前，你需要完成课程 0。所以这是可能的。

示例 2:
输入: 2, [[1,0],[0,1]]
输出: false
解释: 总共有 2 门课程。学习课程 1 之前，你需要先完成​课程 0；并且学习课程 0 之前，你还应先完成课程 1。这是不可能的。

提示：
输入的先决条件是由 边缘列表 表示的图形，而不是 邻接矩阵 。详情请参见图的表示法。
你可以假定输入的先决条件中没有重复的边。
1 <= numCourses <= 10^5

来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/course-schedule
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题解

这个题目是一个典型的有向图的拓扑排序问题。

关于有向图的拓扑排序，可以参考有向图 G=(V, E) 的拓扑排序。

在这道题目中我们可以看到, 选修的课程(活动)之间存在着依赖关系，即先决条件，比如[0, 1]，表示想要学课程0，要先学完课程1。

那么，我们将全部课程看作是有向图$G=(V,E)$的顶点，课程之间的先决条件可以看作是有向图$G=(V,E)$的边。

这里先决条件的表达方式和图论中边的表示方式存在一个不同之处，图论中的一条有向边$u\to v$表示，存在顶点$u$到顶点$v$的一条路径，对应到拓扑排序中，即存在顶点$v$依赖于顶点$u$。

因此，题目描述中的先决条件映射到图论中需要进行转化。举例，先决条件[1,0]，有向边为$0\to 1$。

拓扑排序最终给出的是一种合理地学完全部课程的顺序。

如果所有课程存在着一种合理的顺序，能够顺利完成全部课程的学习，则表明图$G$为有向无环图。若存在某个课程A依赖于课程B，而课程B又依赖于课程A(示例2所示)，则表明图$G$中存在环，则无法完成全部课程的学习。

代码

有向图的拓扑排序有两种解决方法：广度优先和深度优先。下面分别给出BFS和DFS的代码实现。

1. BFS实现

class Solution {
    
public:
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
    
        vector<vector<int>> adjList(numCourses);
        vector<int> inDegreeList(numCourses, 0);
        for (int i = 0; i < prerequisites.size(); i++) {
    
            //(u, v)
            int u = prerequisites[i][1];
            int v =prerequisites[i][0];
            adjList[u].push_back(v);
            inDegreeList[v]++;
        }

        queue<int> bfsQ;
        for (int i = 0; i < inDegreeList.size(); i++) {
    
            if (inDegreeList[i] == 0) {
    
                bfsQ.push(i);
            }
        }

        while (!bfsQ.empty()) {
    
            int node = bfsQ.front();
            bfsQ.pop();
            for (auto &adjNode: adjList[node]) {
    
                inDegreeList[adjNode]--;
                if (inDegreeList[adjNode] == 0) {
    
                    bfsQ.push(adjNode);
                }
            }
        }

        for (auto inDegree: inDegreeList) {
    
            if (inDegree != 0) {
    
                return false;
            }
        }
        return true;
    }
};

2. DFS实现

class Solution {
    
    vector<vector<int>> edges;
    vector<int> visited;
    bool vaild = true;
public:
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
    
        edges.resize(numCourses);
        visited.resize(numCourses);

        for (auto& info: prerequisites) {
    
            edges[info[1]].push_back(info[0]);
        }

        for (int i = 0; i < numCourses; i++) {
    
            if (visited[i] == 0) {
    
                dfs(i);
                if (vaild == false) {
    
                    return false;
                }
            }
        }
        return vaild;
    }

    void dfs(int u) {
    
        visited[u] = 1;
        for (auto& v: edges[u]) {
    
            if (visited[v] == 0) {
    
                dfs(v);
            } else if (visited[v] == 1) {
    
                vaild = false;
                return;
            } else {
    }
        }
        visited[u] = 2;
    }
};