leetcode hot100 之 课程表

题目

你这学习需要学习 numCourses 门课程，编号记为 0 到 numCourses - 1。
在选修某些课程之前你需要完成一些必修课程。先修课程按 prerequisites 给出关系，如 prerequisites[i] = [a_i, b_i]，表示在选修 a_i 之前需要先完成 b_i。
请判断你最终能否完成所有课程。

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

原题链接： https://leetcode.cn/problems/course-schedule/

思路

该题是一道经典的拓扑排序题目。
拓扑排序的定义是：给定一个有 n 个节点的有向图 G，对于节点进行一种编号排列，如果满足，对于任意的有向边 (u, v) 都满足 u 在 v 的前面，则这一种排列是 G 的一种拓扑排序。
对于这道题，只需要判断能否完成课程，而不需要给出具体的上课顺序，也即拓扑排序。降低了难度。
我们利用 prerequisites 来构造图，并判断这是否是一个有向无环图 DAG 即可。

思路1

bfs。
首先利用一个数组来记录有向边，再利用一个数组来记录节点的入度。
然后开始遍历入度为 0 的课程，即没有先修课程 的课程。并将相邻节点的入度 -1。
然后重复上面的步骤，直到所有课程都遍历完成为止。
我们利用一个 count 来记录已遍历的课程，如果所有课程都遍历完成，则说明图中无环，可修完所有课程；反之则完成不了。
节点的遍历过程就是一个拓扑排序。

• 复杂度分析
  • 时间复杂度 O(n+e)。图的bfs遍历，n 个节点，e 条边。
  • 空间复杂度 O(n+e)。

思路2

dfs。
我们利用一个 visited 数组来辅助我们的遍历。
visited 记录三种状态：
0: 表示未搜索
1: 表示搜索中
2: 表示相邻节点已搜索完成

如果在搜索的过程中，遇到环的话，则说明不符合要求，返回 false 即可。
如果需要记录具体的拓扑排序的话，我们只需要依次把 状态2 的节点入栈，则表示排在后面的节点。

• 复杂度分析
  • 时间复杂度 O(n+e)。
  • 空间复杂度 O(n+e)。

代码

代码1

class Solution {
public:
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        vector<vector<int>> edges(numCourses, vector<int>());
        vector<int> indegrees(numCourses, 0);
        int count = 0;

        for (int i = 0; i < prerequisites.size(); i++) {
            int v = prerequisites[i][0];
            int u = prerequisites[i][1];
            edges[u].push_back(v);
            indegrees[v]++;
        }

        queue<int> q;
        for (int i = 0; i < indegrees.size(); i++) {
            if (indegrees[i] == 0) {
                q.push(i);
            }
        }
        while(!q.empty()) {
            int u = q.front();
            q.pop();
            count++;
            for (int i = 0; i < edges[u].size(); i++) {
                int v = edges[u][i];
                indegrees[v]--;
                if (indegrees[v] == 0) {
                    q.push(v);
                }
            }
        }

        return count == numCourses;
    }
};

代码2

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

        for (int i = 0; i < prerequisites.size(); i++) {
            int v = prerequisites[i][0];
            int u = prerequisites[i][1];  
            edges[u].push_back(v);
        }

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

    void dfs(int u, vector<vector<int>>& edges, vector<int>& visited, bool& result) {
        visited[u] = 1;
        for (int& v: edges[u]) {
            if (visited[v] == 0) {
                dfs(v, edges, visited, result);
            }
            else if (visited[v] == 1) {
                result = false;
                return;
            }
        }
        visited[u] = 2;
    }
};