LeetCode 207-课程表

前言

本题是一道经典的「拓扑排序」问题。

给定一个包含 $n$ 个节点的有向图 $G$，我们给出它的节点编号的一种排列，如果满足：对于图 $G$ 的任意一条有向边 $(u,v)$，$u$ 在排列中都出现在 $v$ 的前面。 那么称该排列是图 $G$ 的「拓扑排序」。根据上述定义，我们可以得出两个结论

• 如果图 $G$ 中存在环（即非有向无环图），那么图 $G$ 不存在拓扑排序。
• 如果图 $G$ 是有向无环图，那么它的拓扑排序可能不止一种。

有了上述的简单分析，我们就可以将本题建模成一个求拓扑排序的问题了：

• 我们将每一门课看成一个节点
• 如果想要学习课程 $A$ 之前必须完成课程 $B$，那么我们从 $B$ 到 $A$ 连接一条有向边。

求出该图是否存在拓扑排序，就可以判断是否有一种符合要求的课程学习顺序。事实上，由于求出一种拓扑排序方法的最优时间复杂度为 $O(n+m)$，其中 $n$ 和 $m$ 分别是有向图 $G$ 的节点数和边数。而判断图 $G$ 是否存在拓扑排序，至少也要对其进行一次完整的遍历，时间复杂度也为 $O(n+m)$。

方法一：深度优先搜索

思路
我们可以将深度优先搜索的流程与拓扑排序的求解联系起来，用一个栈来存储所有已经搜索完成的节点。

对于一个节点 $u$，如果它的所有相邻节点都已经搜索完成，那么在搜索回溯到 $u$ 的时候，$u$ 本身也会变成一个已经搜索完成的节点。这里的「相邻节点」指的是从 $u$ 出发通过一条有向边可以到达的所有节点。

假设我们当前搜索到了节点 $u$，如果它的所有相邻节点都已经搜索完成，那么这些节点都已经在栈中了，此时我们就可以把 $u$ 入栈。可以发现，如果我们从栈顶往栈底的顺序看，由于 $u$ 处于栈顶的位置，那么 $u$ 出现在所有 $u$ 的相邻节点的前面。因此对于 $u$ 这个节点而言，它是满足拓扑排序的要求的。

这样一来，我们对图进行一遍深度优先搜索，当每个节点进行回溯的时候，我们把该节点放入栈中，最终从栈顶到栈底的序列就是一种拓扑排序。

算法
对于图中的任意一个节点，它在搜索的过程中有三种状态，即：

• 未搜索：我们还没有搜索到这个节点。
• 搜索中：我们搜索过这个节点，但还没有回溯到该节点，即该节点还没入栈，还有相邻的节点没有搜索完成。
• 已完成：我们搜索过并回溯过这个节点，即该节点已经入栈，并且所有该节点的相邻节点都出现在栈的更底部的位置，满足拓扑排序的要求。

通过上述的三种状态，我们就可以给出使用深度优先搜索得到拓扑排序的算法流程，在每一轮的搜索开始时，我们任取一个未搜索的节点开始进行深度优先搜索。

• 我们将当前搜索的节点 $u$ 标记为 搜索中，遍历该节点的每一个相邻节点 $v$：
  • 如果 $v$ 为 未搜索，那么我们开始搜索 $v$，待搜索完成回溯到 $u$；
  • 如果 $v$ 为 搜索中，那么我们就找到了图中的一个环，因此是不存在拓扑排序的；
  • 如果 $v$ 为 已完成，那么说明 $v$ 已经在栈中了，而 $u$ 还不在栈中，因此 $u$ 无论何时入栈都不会影响到 $(u,v)$ 之前的拓扑关系；
• 当 $u$ 的所有相邻节点都为 已完成 时，我们将 $u$ 放入栈中，并将其标记为 已完成。

在整个深度优先搜索的过程结束后，如果我们没有找到图中的环，那么栈中存储这所有的 $n$ 个节点，从栈顶到栈底的顺序即为一种拓扑排序。

优化
由于我们只需要判断是否存在一种拓扑排序，而栈的作用仅仅是存放最终的拓扑排序结果，因此我们可以只记录每个节点的状态，而省去对应的栈。

代码

class Solution {
private:
    vector<vector<int>> edges;                  
    vector<int> visited;                        //标记数组
    bool valid = true;                          //判断是否存在拓扑排序

public:
    void dfs(int u){
        visited[u] = 1;                         //标记为搜索中
        for(int v : edges[u]){
            if(visited[v] == 0){                //v为未搜索，开始搜索
                dfs(v);
                if(!valid)                      //剪枝，若已发现有环，则停止搜索，直接返回
                    return;
            }else if(visited[v] == 1){          //v为搜索中，说明有环
                valid = false;
                return;
            }
        }
        visited[u] = 2;                         //已完成
    }

    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        edges.resize(numCourses);
        visited.resize(numCourses);
        for(const auto& info: prerequisites){   //构造有向图的邻接表
            edges[info[1]].push_back(info[0]);
        }
        for(int i = 0; i < numCourses && valid; ++i){
            if(!visited[i]){                   //如果未搜索到这个节点
                dfs(i);
            }
        }
        return valid;
    }
};

复杂度分析

• 时间复杂度：$O(n+m)$，其中 $n$ 为课程数，$m$ 为先修课程的要求数。
• 空间复杂度：$O(n+m)$

方法二：广度优先搜索

思路
方法一的深度优先搜索是一种逆向思维：最先被放入栈中的节点是在拓扑排序中最后面的节点。我们也可以使用正向思维，顺序地生成拓扑排序，这种方法也更加直观。

我们考虑拓扑排序中最前面的节点，该节点一定不会有任何入边，也就是它没有任何的先修课程要求。当我们将一个节点加入答案中后，我们就可以移除它的所有出边，代表着它的相邻节点少了一门先修课程的要求。如果某个相邻节点变成了没有任何入边的节点，那么就代表着这门课可以开始学习了。按照这样的流程，我们不断地将没有入边的节点加入答案，知道答案中包含所有的节点或者不存在没有入边的节点。

上面的想法类似于广度优先搜索，因此我们可以将广度优先搜索的流程与拓扑排序的求解联系起来。

算法
我们使用一个队列来进行广度优先搜索。初始时，所有入度为 $0$ 的节点都被放入队列中，它们就是可以作为拓扑排序最前面的节点，并且它们之间的相对顺序是无关紧要的。

在广度优先搜索的每一步中，我们取出队首的节点 $u$：

• 我们将 $u$ 放入答案中
• 我们移除 $u$ 的所有出边，也就是将 $u$ 的所有相邻节点的入度减少 $1$。如果某个相邻节点 $v$ 的入度变为 $0$，那么我们就将 $v$ 放入队列中。

在广度优先搜索的过程结束后。如果答案中包含了这 $n$ 个节点，那么我们就找到了一种拓扑排序，否则说明图中存在环，也就不存在拓扑排序了。

优化
由于我们只需要判断是否存在一种拓扑排序，因此我们省去存放答案数组，而是只用一个变量记录被放入答案数组的节点个数。在广度优先搜索结束之后，我们判断该变量的值是否等于课程数，就能知道是否存在一种拓扑排序。

代码

class Solution {
private:
    vector<vector<int>> edges;                          //存储有向图的邻接表
    vector<int> indeg;                                  //存储节点的入度

public:
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        edges.resize(numCourses);
        indeg.resize(numCourses);
        for(const auto& info: prerequisites){           //初始化有向图的邻接表和入度表
            edges[info[1]].push_back(info[0]);          
            ++indeg[info[0]];
        }
        queue<int> q;
        for(int i = 0; i < numCourses; ++i){            //入度为0的节点入队
            if(indeg[i] == 0){
                q.push(i);
            }
        }

        int visited = 0;                                //记录访问过的节点数
        while(!q.empty()){
            ++visited;
            int u = q.front();
            q.pop();
            for(int v: edges[u]){                       //移除u的所有出边，即u的相邻节点的入度减1
                --indeg[v];
                if(indeg[v] == 0)                       //若减小后入度为0，则入队
                    q.push(v);
            }
        }
        return visited == numCourses;
    }
};

复杂度分析

• 时间复杂度：$O(n+m)$，$n$ 为课程数，$m$ 为先修课程的要求数
• 空间复杂度：$O(n+m)$

方法一：深度优先搜索

class Solution {
private:
    vector<vector<int>> edges;                  
    vector<int> visited;                        //标记数组,0-未搜索，1-搜索中，2-已完成
    bool valid = true;                          //判断是否存在拓扑排序
    vector<int> result;                         //用数组来模拟栈

public:
    void dfs(int u){
        visited[u] = 1;                         //标记为搜索中
        for(int v : edges[u]){
            if(visited[v] == 0){                //v为未搜索，开始搜索
                dfs(v);
                if(!valid)                      //剪枝，若已发现有环，则停止搜索，直接返回
                    return;
            }else if(visited[v] == 1){          //v为搜索中，说明有环
                valid = false;
                return;
            }
        }
        visited[u] = 2;                         //已完成
        result.push_back(u);                    //将节点入栈
    }

public:
    vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
        edges.resize(numCourses);
        visited.resize(numCourses);
        for(const auto& info: prerequisites){   //构造有向图的邻接表
            edges[info[1]].push_back(info[0]);
        }
        for(int i = 0; i < numCourses && valid; ++i){
            if(!visited[i]){                   //如果未搜索到这个节点
                dfs(i);
            }
        }
        if(!valid)
            return {};
        reverse(result.begin(), result.end());
        return result;
    }
};

方法二：广度优先搜索

class Solution {
private:
    vector<vector<int>> edges;                          //存储有向图的邻接表
    vector<int> indeg;                                  //存储节点的入度

public:
    vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
        edges.resize(numCourses);
        indeg.resize(numCourses);
        for(const auto& info: prerequisites){           //初始化有向图的邻接表和入度表
            edges[info[1]].push_back(info[0]);          
            ++indeg[info[0]];
        }
        queue<int> q;
        for(int i = 0; i < numCourses; ++i){            //入度为0的节点入队
            if(indeg[i] == 0){
                q.push(i);
            }
        }

        vector<int> ans;                                //记录拓扑排序结果
        while(!q.empty()){
            int u = q.front();
            ans.push_back(u);                           //加入结果数组
            q.pop();
            for(int v: edges[u]){                       //移除u的所有出边，即u的相邻节点的入度减1
                if(--indeg[v] == 0)                     //若减小后入度为0，则入队
                    q.push(v);
            }
        }
        return ans.size() == numCourses ? ans : vector<int>();
    }
};