1. 课程表问题的图论本质
课程表问题（LeetCode 207题）本质上是一个经典的有向图环检测问题。想象你是一名大学教务系统的开发者，需要设计一个功能来判断学生能否按照给定的课程先修关系完成所有课程。这就像是在检查一个复杂的任务依赖链中是否存在循环依赖。
1.1 问题建模
给定numCourses门课程（编号从0到numCourses-1）和prerequisites数组（表示课程间的先修关系），我们需要判断是否存在合法的课程学习顺序。例如：
- 输入：numCourses = 4, prerequisites = [[1,0],[2,0],[3,1],[3,2]]
- 解释：要学习课程1需要先完成课程0，课程2也需要先完成课程0，课程3需要完成课程1和课程2
- 输出：true（存在合法学习顺序：0→1→2→3或0→2→1→3）
这个问题可以转化为图论中的拓扑排序问题。我们构建一个有向图：
- 顶点：每门课程
- 边：从先修课程指向后续课程
1.2 环的判定标准
在有向图中，如果存在一个环，就意味着存在一组课程相互依赖，导致无法确定学习顺序。例如A依赖B，B依赖C，C又依赖A，这就形成了一个死循环。
判断图中是否存在环的标准方法是深度优先搜索（DFS）中的"递归栈检测"：如果在探索某条路径时，发现当前节点已经在递归调用栈中（即正在被访问），就说明发现了环。
2. 深度优先搜索的实现细节
2.1 图的表示方法
我们使用邻接表来表示图，这是处理稀疏图（边数远小于完全图）最高效的方式。在Java中，可以用List<Integer>[]结构：
java复制List<Integer>[] g = new ArrayList[numCourses];
for (int i = 0; i < numCourses; i++) {
g[i] = new ArrayList<>();
}
for (int[] p : prerequisites) {
g[p[1]].add(p[0]); // p[1]是前置课程，p[0]是后续课程
}
这种表示法的优势在于：
- 空间复杂度仅为O(V+E)，V是顶点数，E是边数
- 可以快速访问任意节点的所有邻居
- 适合DFS/BFS遍历
2.2 三色标记法
传统的DFS环检测使用"三色标记法"来跟踪节点状态：
- 0（白色）：节点未被访问
- 1（灰色）：节点正在被访问（在递归栈中）
- 2（黑色）：节点已完成访问
关键点在于：如果在DFS过程中遇到灰色节点，说明发现了环。这与拓扑排序的思想密切相关。
2.3 DFS递归实现
java复制private boolean hasCycle = false;
private void dfs(int x, List<Integer>[] g, int[] state) {
if (state[x] == 2) return; // 已完成的节点无需处理
if (state[x] == 1) { // 遇到正在访问的节点→发现环
hasCycle = true;
return;
}
state[x] = 1; // 标记为正在访问
for (int neighbor : g[x]) {
dfs(neighbor, g, state);
}
state[x] = 2; // 标记为已完成
}
注意：必须使用三色标记而非二色标记。如果只用"已访问/未访问"两种状态，会误判某些情况（如跨树访问已完成的节点）。
3. 完整算法实现与优化
3.1 主函数逻辑
java复制public boolean canFinish(int numCourses, int[][] prerequisites) {
// 构建图
List<Integer>[] g = new ArrayList[numCourses];
for (int i = 0; i < numCourses; i++) {
g[i] = new ArrayList<>();
}
for (int[] p : prerequisites) {
g[p[1]].add(p[0]);
}
int[] state = new int[numCourses]; // 0:未访问, 1:访问中, 2:已完成
// 需要检查所有连通分量
for (int i = 0; i < numCourses; i++) {
if (state[i] == 0) {
dfs(i, g, state);
if (hasCycle) break;
}
}
return !hasCycle;
}
3.2 复杂度分析
- 时间复杂度：O(V+E)
- 每个节点最多被访问一次（标记为黑色后不再处理）
- 每条边最多被遍历一次
- 空间复杂度：O(V+E)
- 邻接表存储需要O(V+E)空间
- 递归栈深度最坏情况下为O(V)
3.3 非递归实现（栈模拟DFS）
对于大规模图，递归DFS可能导致栈溢出。可以使用显式栈实现迭代版DFS：
java复制private boolean dfsWithStack(int start, List<Integer>[] g, int[] state) {
Deque<Integer> stack = new ArrayDeque<>();
stack.push(start);
while (!stack.isEmpty()) {
int x = stack.peek();
if (state[x] == 0) {
state[x] = 1;
for (int neighbor : g[x]) {
if (state[neighbor] == 1) return true; // 发现环
if (state[neighbor] == 0) {
stack.push(neighbor);
}
}
} else {
state[x] = 2;
stack.pop();
}
}
return false;
}
4. 常见问题与调试技巧
4.1 边界条件处理
-
空输入处理：
- numCourses为0时应该返回true
- prerequisites为空数组时，只要numCourses≥0就返回true
-
无效输入检测：
- 课程编号应在[0, numCourses-1]范围内
- 自环（如[1,1]）直接视为环
4.2 调试技巧
当算法出现错误时，可以：
- 打印邻接表，确认图构建正确
- 在DFS过程中打印状态变化：
java复制System.out.println("访问节点"+x+", 状态变为"+state[x]); - 使用小型测试用例手动模拟执行过程
4.3 性能优化
- 提前终止：一旦发现环立即终止搜索
- 并行搜索：对于大规模图，可以考虑并行处理不同连通分量
- 内存优化：对于固定课程数（如≤1000），可以用位运算代替状态数组
5. 拓扑排序的替代解法
除了DFS，还可以用Kahn算法（基于入度统计）进行拓扑排序：
java复制public boolean canFinish(int numCourses, int[][] prerequisites) {
List<Integer>[] g = new ArrayList[numCourses];
int[] inDegree = new int[numCourses];
for (int i = 0; i < numCourses; i++) {
g[i] = new ArrayList<>();
}
for (int[] p : prerequisites) {
g[p[1]].add(p[0]);
inDegree[p[0]]++;
}
Queue<Integer> q = new LinkedList<>();
for (int i = 0; i < numCourses; i++) {
if (inDegree[i] == 0) q.offer(i);
}
int count = 0;
while (!q.isEmpty()) {
int x = q.poll();
count++;
for (int neighbor : g[x]) {
if (--inDegree[neighbor] == 0) {
q.offer(neighbor);
}
}
}
return count == numCourses;
}
Kahn算法的特点：
- 更适合并行处理
- 可以输出具体的拓扑排序结果
- 空间复杂度略高（需要维护入度表和队列）
在实际开发中，如果只需要判断能否完成（而不需要具体顺序），DFS方法通常更简洁高效。但如果系统后续需要提供课程学习顺序，Kahn算法更为合适。