编程训练第一百零八期——课程表

编程问题：

你这个学期必须选修 numCourses 门课程，记为 0 到 numCourses - 1 。在选修某些课程之前需要一些先修课程。 先修课程按数组 prerequisites 给出，其中 prerequisites[i] = [ai, bi] ，表示如果要学习课程 ai 则 必须 先学习课程 bi 。例如，先修课程对 [0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1 。
请你判断是否可能完成所有课程的学习？如果可以，返回 true ；否则，返回 false 。

---

示例：

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

---

解法：

1.广度优先遍历

• 首先统计课程安排图中每个节点的入度，生成入度表 degree。
• 借助一个队列 que，用来将所有入度为 0 的节点入队。当 que 非空时，依次将队首节点出队，并将此节点对应所有邻接节点的入度 −1，即 degree[cur] -= 1。当入度 −1后邻接节点的入度为 0，说明此结点的所有前驱节点已经被 “删除”，此时将此结点入队。
• 若整个课程安排图是有向无环图（即可以安排），则所有节点一定都入队并出队过，即完成拓扑排序。换个角度说，若课程安排图中存在环，一定有节点的入度始终不为 0。因此，拓扑排序出队次数等于课程个数，返回 numCourses == 0 判断课程是否可以成功安排。

时间复杂度 O(N+M)，遍历一个图需要访问所有节点和所有边，N 和 M 分别为节点数量和边数量；
空间复杂度 O(N+M)，为建立邻接表所需额外空间，adjacency 长度为 N ，并存储 M 条边的数据。

class Solution {
public:
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        vector<int> degree(numCourses);
        vector<vector<int>> adjacency(numCourses);
        int num = numCourses;
        for (vector<int> x : prerequisites)
        {
            degree[x[0]]++;
            adjacency[x[1]].push_back(x[0]);
        }
        queue<int> que;
        for (int i = 0; i < numCourses; i++)
            if (degree[i] == 0)
            {
                que.push(i);
                num--;
            }

        while (!que.empty())
        {
            int cur = que.front();
            que.pop();
            for (int j = 0; j < adjacency[cur].size(); j++)
            {
                if (--degree[adjacency[cur][j]] == 0)
                {
                    que.push(adjacency[cur][j]);
                    num--;
                }
            }
        }

        if (num == 0)
            return true;
        return false;
            
    }
};

2.深度优先遍历
借助一个标志列表visited，用于判断每个节点 i （课程）的状态：

• 未被 dfs 访问：i == 0；
• 已被其他节点启动的 dfs 访问：i == -1；
• 已被当前节点启动的 dfs 访问：i == 1。

对 numCourses 个节点依次执行 dfs，判断每个节点起步 dfs 是否存在环，若存在环直接返回 False。

递归终止条件：

• 当 visited[i] == -1，说明当前访问节点已被其他节点启动的 dfs 访问，无需再重复搜索，直接返回 True。
• 当 visited[i] == 1，说明在本轮 dfs 搜索中节点 i 被第 2 次访问，即 课程安排图有环 ，直接返回 False。

将当前访问节点 i 对应 visited[i] 置 1，即标记其被本轮 dfs 访问过；递归访问当前节点 i 的所有邻接节点 j，当发现环直接返回 False；当前节点所有邻接节点已被遍历，并没有发现环，则将当前节点 visited 置为 −1 并返回 True。若整个图 dfs 结束并未发现环，返回 True。

时间复杂度 O(N + M)，遍历一个图需要访问所有节点和所有边，N 和 M 分别为节点数量和边数量；
空间复杂度 O(N + M)，为建立邻接表所需额外空间，adjacency 长度为 N ，并存储 M 条边的数据。

class Solution {
private:
    bool dfs(int i, vector<vector<int>>& adjacency, vector<int>& visited)
    {
        if (visited[i] == -1)
            return true;
        if (visited[i] == 1)
            return false;
        visited[i] = 1;
        for (int x : adjacency[i])
            if(!dfs(x, adjacency, visited))
                return false;
        visited[i] = -1;
        return true;
    }

public:
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        vector<vector<int>> adjacency(numCourses);
        vector<int> visited(numCourses);
        for (vector<int> x : prerequisites)
            adjacency[x[1]].push_back(x[0]);
        for (int i = 0; i < numCourses; i++)
        {
            if(!dfs(i, adjacency, visited))
                return false;
        }
        return true;
    }
};