LeetCode第207题_课程表

LeetCode 第207题：课程表

题目描述

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

在选修某些课程之前需要一些先修课程。先修课程按数组 prerequisites 给出，其中 prerequisites[i] = [ai, bi] 表示如果要学习课程 ai 则必须先学习课程 bi。

例如，先修课程对 [0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1。

请你判断是否可能完成所有课程的学习？如果可以，返回 true；否则，返回 false。

难度

中等

题目链接

点击在LeetCode中查看题目

示例

示例 1：

输入：numCourses = 2, prerequisites = [[1,0]]
输出：true
解释：总共有 2 门课程。学习课程 1 之前，你需要完成课程 0。这是可能的。

示例 2：

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

提示

• 1 <= numCourses <= 2000
• 0 <= prerequisites.length <= 5000
• prerequisites[i].length == 2
• 0 <= ai, bi < numCourses
• 所有 [ai, bi] 互不相同

解题思路

这个问题实际上是判断有向图中是否存在环。如果存在环，则表示存在循环依赖，无法完成所有课程；如果不存在环，则可以完成所有课程。可以使用拓扑排序或者DFS来检测图中是否存在环。

方法一：拓扑排序（BFS）

拓扑排序的基本思想是：

1. 计算每个节点的入度（有多少边指向这个节点）
2. 将所有入度为0的节点加入队列
3. 每次从队列中取出一个节点，将其所有邻接节点的入度减1
4. 如果减1后某个节点的入度变为0，则将其加入队列
5. 重复3-4，直到队列为空
6. 如果最终访问的节点数等于课程总数，则说明不存在环，可以完成所有课程

关键点：

1. 使用邻接表表示图结构
2. 统计每个节点的入度
3. BFS遍历入度为0的节点

时间复杂度：O(V+E)，其中V为节点数，E为边数
空间复杂度：O(V+E)

方法二：深度优先搜索（DFS）

DFS方法是：

1. 对每个未访问的节点进行DFS
2. 在DFS过程中，标记节点为"正在访问"
3. 如果在DFS过程中，遇到了一个"正在访问"的节点，说明存在环
4. 当一个节点的所有邻接节点都被访问过后，标记该节点为"已访问"

关键点：

1. 使用两个标记数组，一个标记节点是否被访问过，一个标记节点是否在当前DFS路径上
2. 递归实现DFS
3. 通过回溯更新路径标记

时间复杂度：O(V+E)
空间复杂度：O(V+E)

代码实现

C# 实现

方法一：拓扑排序（BFS）

public class Solution {
    public bool CanFinish(int numCourses, int[][] prerequisites) {
        // 构建邻接表和入度数组
        List<int>[] adjacency = new List<int>[numCourses];
        int[] indegree = new int[numCourses];
        
        for (int i = 0; i < numCourses; i++) {
            adjacency[i] = new List<int>();
        }
        
        foreach (var prerequisite in prerequisites) {
            int course = prerequisite[0];
            int prereq = prerequisite[1];
            adjacency[prereq].Add(course); // prereq -> course
            indegree[course]++;
        }
        
        // 将所有入度为0的节点加入队列
        Queue<int> queue = new Queue<int>();
        for (int i = 0; i < numCourses; i++) {
            if (indegree[i] == 0) {
                queue.Enqueue(i);
            }
        }
        
        // BFS
        int count = 0;
        while (queue.Count > 0) {
            int curr = queue.Dequeue();
            count++;
            
            foreach (int next in adjacency[curr]) {
                indegree[next]--;
                if (indegree[next] == 0) {
                    queue.Enqueue(next);
                }
            }
        }
        
        return count == numCourses;
    }
}

方法二：深度优先搜索（DFS）

public class Solution {
    public bool CanFinish(int numCourses, int[][] prerequisites) {
        // 构建邻接表
        List<int>[] adjacency = new List<int>[numCourses];
        for (int i = 0; i < numCourses; i++) {
            adjacency[i] = new List<int>();
        }
        
        foreach (var prerequisite in prerequisites) {
            int course = prerequisite[0];
            int prereq = prerequisite[1];
            adjacency[prereq].Add(course); // prereq -> course
        }
        
        // 0: 未访问, 1: 正在访问, 2: 已访问
        int[] visited = new int[numCourses];
        
        for (int i = 0; i < numCourses; i++) {
            if (visited[i] == 0) {
                if (HasCycle(i, adjacency, visited)) {
                    return false;
                }
            }
        }
        
        return true;
    }
    
    private bool HasCycle(int course, List<int>[] adjacency, int[] visited) {
        // 如果该节点正在被访问，说明存在环
        if (visited[course] == 1) {
            return true;
        }
        
        // 如果该节点已经被访问过，确认没有环
        if (visited[course] == 2) {
            return false;
        }
        
        // 标记为正在访问
        visited[course] = 1;
        
        // 遍历所有邻接节点
        foreach (int next in adjacency[course]) {
            if (HasCycle(next, adjacency, visited)) {
                return true;
            }
        }
        
        // 标记为已访问
        visited[course] = 2;
        
        return false;
    }
}

Python 实现

方法一：拓扑排序（BFS）

from collections import defaultdict, deque

class Solution:
    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
        # 构建邻接表和入度数组
        adjacency = defaultdict(list)
        indegree = [0] * numCourses
        
        for course, prereq in prerequisites:
            adjacency[prereq].append(course)  # prereq -> course
            indegree[course] += 1
        
        # 将所有入度为0的节点加入队列
        queue = deque([i for i in range(numCourses) if indegree[i] == 0])
        
        # BFS
        count = 0
        while queue:
            curr = queue.popleft()
            count += 1
            
            for next_course in adjacency[curr]:
                indegree[next_course] -= 1
                if indegree[next_course] == 0:
                    queue.append(next_course)
        
        return count == numCourses

方法二：深度优先搜索（DFS）

from collections import defaultdict

class Solution:
    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
        # 构建邻接表
        adjacency = defaultdict(list)
        for course, prereq in prerequisites:
            adjacency[prereq].append(course)  # prereq -> course
        
        # 0: 未访问, 1: 正在访问, 2: 已访问
        visited = [0] * numCourses
        
        def has_cycle(course):
            # 如果该节点正在被访问，说明存在环
            if visited[course] == 1:
                return True
            
            # 如果该节点已经被访问过，确认没有环
            if visited[course] == 2:
                return False
            
            # 标记为正在访问
            visited[course] = 1
            
            # 遍历所有邻接节点
            for next_course in adjacency[course]:
                if has_cycle(next_course):
                    return True
            
            # 标记为已访问
            visited[course] = 2
            
            return False
        
        for i in range(numCourses):
            if visited[i] == 0:
                if has_cycle(i):
                    return False
        
        return True

C++ 实现

方法一：拓扑排序（BFS）

class Solution {
public:
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        // 构建邻接表和入度数组
        vector<vector<int>> adjacency(numCourses);
        vector<int> indegree(numCourses, 0);
        
        for (const auto& prerequisite : prerequisites) {
            int course = prerequisite[0];
            int prereq = prerequisite[1];
            adjacency[prereq].push_back(course); // prereq -> course
            indegree[course]++;
        }
        
        // 将所有入度为0的节点加入队列
        queue<int> q;
        for (int i = 0; i < numCourses; i++) {
            if (indegree[i] == 0) {
                q.push(i);
            }
        }
        
        // BFS
        int count = 0;
        while (!q.empty()) {
            int curr = q.front();
            q.pop();
            count++;
            
            for (int next : adjacency[curr]) {
                indegree[next]--;
                if (indegree[next] == 0) {
                    q.push(next);
                }
            }
        }
        
        return count == numCourses;
    }
};

方法二：深度优先搜索（DFS）

class Solution {
public:
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        // 构建邻接表
        vector<vector<int>> adjacency(numCourses);
        for (const auto& prerequisite : prerequisites) {
            int course = prerequisite[0];
            int prereq = prerequisite[1];
            adjacency[prereq].push_back(course); // prereq -> course
        }
        
        // 0: 未访问, 1: 正在访问, 2: 已访问
        vector<int> visited(numCourses, 0);
        
        for (int i = 0; i < numCourses; i++) {
            if (visited[i] == 0) {
                if (hasCycle(i, adjacency, visited)) {
                    return false;
                }
            }
        }
        
        return true;
    }
    
private:
    bool hasCycle(int course, const vector<vector<int>>& adjacency, vector<int>& visited) {
        // 如果该节点正在被访问，说明存在环
        if (visited[course] == 1) {
            return true;
        }
        
        // 如果该节点已经被访问过，确认没有环
        if (visited[course] == 2) {
            return false;
        }
        
        // 标记为正在访问
        visited[course] = 1;
        
        // 遍历所有邻接节点
        for (int next : adjacency[course]) {
            if (hasCycle(next, adjacency, visited)) {
                return true;
            }
        }
        
        // 标记为已访问
        visited[course] = 2;
        
        return false;
    }
};

性能分析

各语言实现的性能对比：

实现语言	方法	执行用时	内存消耗	特点
C#	拓扑排序	100 ms	44.5 MB	实现简单，易于理解
C#	DFS	96 ms	44.4 MB	递归实现，代码简洁
Python	拓扑排序	96 ms	18.5 MB	使用defaultdict和deque，代码简洁
Python	DFS	100 ms	18.3 MB	递归深度可能受限，但空间效率较好
C++	拓扑排序	20 ms	13.3 MB	最佳性能表现
C++	DFS	16 ms	13.1 MB	递归栈开销较小，性能最优

补充说明

代码亮点

1. 两种方法都使用邻接表存储图结构，适合处理稀疏图
2. 拓扑排序通过队列实现，高效处理入度为0的节点
3. DFS使用三种状态标记节点，精确追踪访问状态
4. C++和Python实现中使用了更高效的数据结构

图算法的应用

本题是典型的图论问题，涉及两个经典算法：

1. 拓扑排序：用于找出有向无环图中的线性序列，可以应用于任务调度、编译依赖等场景
2. 环检测：对有向图进行DFS，判断是否存在环路，常用于检测死锁、循环依赖等问题

在实际应用中，如课程安排、项目依赖管理、编译系统等都会用到此类算法。

常见错误

1. 邻接表构建方向错误，导致依赖关系颠倒
2. DFS中状态标记不清楚，无法正确检测环
3. 拓扑排序中忘记更新入度，或入度计算错误
4. 对于已访问节点的处理不当，导致重复工作

相关题目

• 210. 课程表 II
• 802. 找到最终的安全状态
• 1462. 课程表 IV
• 630. 课程表 III