拓扑排序 (2/10) —— 力扣刷题 207. 课程表

已于 2025-04-15 10:02:42 修改
阅读量1.2k 收藏 16
点赞数 29
分类专栏： 图论与算法 拓扑排序 文章标签： 算法 图论 拓扑排序 数据结构
于 2025-04-12 19:07:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/smileyan9/article/details/147164586
版权

在这里插入图片描述

题目链接：https://leetcode.cn/problems/course-schedule/description/
题目难度：中等
相关标签：拓扑排序 / 广度优先搜搜 BFS / 深度优先搜索 DFS

2.1 问题与分析

2.1.1 原题截图

在这里插入图片描述

2.1.2 题目分析

首先，理解题目后必须马上意识到考察的是 图论类型中的有向图问题，接着考虑到有向图之间的关系，可以想到我们在本系列第一篇 博客 提到的 拓扑排序。

接着，这里将题目进一步简化：

给你 numCourses 门课程，和若干课程依赖关系 prerequisites，问你能否顺利修完所有课程。

换句话说：

  • 每门课程是一个节点。

  • 依赖关系是一个有向边（比如 [1, 0] 表示：想学 1，必须先学 0）。

这就构成了一个有向图，问题变成了：

这个图有没有环？

  • 有环 = 某些课程互相依赖，永远无法完成。

  • 无环 = 可以通过拓扑排序找到学习顺序。

在本系列的第一篇博客已经提到过，拓扑排序可以用来解决 判断有向图中是否有环问题。

最后已经大概怎么知道解决问题了，那么请回答这个问题 如何通过拓扑排序解决有向图中是否有环问题。

2.2 解法 1 —— 基于广度优先搜索（BFS）的拓扑排序（Kahn 算法）

不急着写代码，我们先用文字的形式，描述清楚解题思路。

2.2.1 解题思路

解题思路：

  1. 构建图结构，使用二维数组存储，记作 graph；
  2. 统计每个结点的入度，使用一维数组存储，记作 inCounts
  3. 维护一个队列 Q，将 inCounts 中入度为 0 的元素入队；
  4. 基于队列进行操作，将访问的结点存储到 results 数组中。
    a. 对于队中每个元素 e，将它的相邻结点的入度 减 1；
    b. 如果 减 1 后的结点入度为 0，加入队列 Q；
    c. 将 e 写入 results 数组。
    d. e 出列，循环此项操作。
  5. 判定 results 数组长度是否与所有元素数目相等。相等表示可以正常访问所有结点，原拓扑 无环，返回 true，否则返回 false。

复杂度分析：

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

2.2.2 代码实现

前面已经将解题方法写明白了，写代码就很方便了，我们分别使用 C++ / python 与 java 三种语言实现。

基于 C++ 的代码实现

实现思路请参考前文，先理解思路再看代码。

class Solution {
public:
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        vector<int> inCount(numCourses);
        vector<vector<int>> graph(numCourses);
        // [0, 1] 表示，需要先学习课程 1，才能学习课程 0
        // Step 1: 构建图
        // Step 2: 统计入度
        for (const auto& par: prerequisites) {
            graph[par[1]].push_back(par[0]);
            inCount[par[0]]++;
        }
        // Step 3: 初始化队列
        queue<int> Q;
        for (int i=0; i<numCourses; i++) {
            if (inCount[i] == 0) {
                Q.push(i);
            }
        }

		// Step 4: 基于队列进行遍历
        vector<int> results;
        while (!Q.empty()) {
            auto front = Q.front();
            Q.pop();
            results.push_back(front);
            for (auto v: graph[front]) {
                inCount[v]--;
                if (inCount[v] == 0) {
                    Q.push(v);
                }
            }
        }

        return results.size() == numCourses;
    }
};
基于 python 的代码实现

实现思路请参考前文，先理解思路再看代码。

class Solution:
    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
        inCount = [0] * numCourses
        graph = [[] for _ in range(numCourses)]
        # [0, 1] 表示，需要先学习课程 1，才能学习课程 0
        # Step 1: 构建图
        # Step 2: 统计入度
        for par in prerequisites:
            graph[par[1]].append(par[0])
            inCount[par[0]] += 1

        # Step 3: 初始化队列
        Q = deque()
        for i in range(numCourses):
            if inCount[i] == 0:
                Q.append(i)

        # Step 4:
        results = []
        while Q:
            front = Q.popleft()
            results.append(front)
            for v in graph[front]:
                inCount[v] -= 1
                if inCount[v] == 0:
                    Q.append(v)

        return len(results) == numCourses
基于 java 的代码实现

实现思路请参考前文，先理解思路再看代码。

class Solution {
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        int[] inCount = new int[numCourses];
        List<List<Integer>> graph = new ArrayList<>();
        for (int i = 0; i < numCourses; i++) {
            graph.add(new ArrayList<>());
        }

        // [0, 1] 表示，需要先学习课程 1，才能学习课程 0
        // Step 1: 构建图
        // Step 2: 统计入度
        for (int[] par : prerequisites) {
            graph.get(par[1]).add(par[0]);
            inCount[par[0]]++;
        }

        // Step 3: 初始化队列
        Queue<Integer> Q = new LinkedList<>();
        for (int i = 0; i < numCourses; i++) {
            if (inCount[i] == 0) {
                Q.offer(i);
            }
        }

        // Step 4:
        List<Integer> results = new ArrayList<>();
        while (!Q.isEmpty()) {
            int front = Q.poll();
            results.add(front);
            for (int v : graph.get(front)) {
                inCount[v]--;
                if (inCount[v] == 0) {
                    Q.offer(v);
                }
            }
        }

        return results.size() == numCourses;
    }
}

2.3 解法 2 —— 基于深度优先搜索（DFS）的拓扑排序

前面已经将解题方法写明白了，写代码就很方便了，我们分别使用 C++ / python 与 java 三种语言实现。

2.3.1 解题思路

解题思路：

  1. 构建图，使用二维数组 graph 保存图的结构；
  2. 初始化过程：
    a. 初始化一维数组 visited，它的每个元素含有三个状态 0 表示未访问过，1 表示已经访问过，2 表示已经记录到最终结果数组中。注意这个地方必须保证更新顺序，也就是 0 -> 1 -> 2。
    b. 初始化 valid 变量，表示DFS过程中是否遇到 环，比如遇到环了就结束。
    c. 初始化 results 数组，用于记录已经访问过的路径。
  3. DFS 过程，该过程对每一个未访问过的结点进行考察，对于结点 e，完成操作包括：
    a. 更新 visited 数组，标记 e 结点已经被访问过。
    b. DFS 访问与 e 结点连接的其他结点。
    c. 如果下一个结点 visited 状态为 0， 则继续DFS；如果状态为 2，则说明有环，更新 valid 结束 DFS。
    d. 访问 e 结点的所有相邻结点后，将 e 记录到 results 中。
    e. 访问 e 结点以后，更新 visited[e] 的状态为 2，表示已经记录到 results 数组中。
  4. 判定 results 数组长度是否与所有元素数目相等。相等表示可以正常访问所有结点，原拓扑 无环，返回 true，否则返回 false。

关键算法说明：

  • DFS拓扑排序：通过后序遍历将节点加入结果集，天然形成逆拓扑序
  • 环检测机制：当遇到visited[v] == 1时，说明存在回边（即环）
  • 三色标记法：

    • 0（白色）：未访问

    • 1（灰色）：访问中（递归栈中）

    • 2（黑色）：已访问且所有后继处理完成

2.3.2 代码实现

基于 C++ 的代码实现

实现思路请参考前文，先理解思路再看代码。

class Solution {
private:
    bool valid = true;  // 标记是否有环，默认可以完成所有课程（无环）
    vector<int> visited;  // 标记每个节点的访问状态：0 = 未访问，1 = 正在访问，2 = 已完成访问
    vector<vector<int>> graph;  // 邻接表，表示课程之间的依赖图

    // 深度优先搜索判断是否存在环
    void dfs(int i) {
        visited[i] = 1;  // 标记为正在访问中
        for (auto v: graph[i]) {
            if (visited[v] == 0) {
                // 如果邻接节点未访问，继续 DFS
                dfs(v);
                if (!valid) return;  // 如果已经发现环，提前退出
            } else if (visited[v] == 1) {
                // 如果邻接节点正在访问中，说明存在环
                valid = false;
                return;
            }
        }
        visited[i] = 2;  // 标记为访问完成
    }

public:
    // 主要思路：判断是否可以完成所有课程（即图中是否存在环）
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        // 初始化图结构（邻接表）
        graph = vector<vector<int>>(numCourses);
        for (const auto& par: prerequisites) {
            graph[par[1]].push_back(par[0]);  // 课程 par[0] 依赖于 par[1]
        }

        visited = vector<int>(numCourses, 0);  // 初始化所有节点为未访问状态
        for (int i = 0; i < numCourses && valid; i++) {
            if (visited[i] == 0) {
                dfs(i);  // 从未访问的节点开始 DFS
            }
        }

        return valid;  // 若无环，则返回 true；否则返回 false
    }
};
基于 python 的代码实现

实现思路请参考前文，先理解思路再看代码。

class Solution:
    def __init__(self):
        self.valid = True  # 标记是否有环，默认可以完成所有课程（无环）
        self.visited = []  # 标记每个节点的访问状态：0 = 未访问，1 = 正在访问，2 = 已完成访问
        self.graph = []    # 邻接表，表示课程之间的依赖图

    # 深度优先搜索判断是否存在环
    def dfs(self, i):
        self.visited[i] = 1  # 标记为正在访问中
        for v in self.graph[i]:
            if self.visited[v] == 0:
                # 如果邻接节点未访问，继续 DFS
                self.dfs(v)
                if not self.valid:
                    return  # 如果已经发现环，提前退出
            elif self.visited[v] == 1:
                # 如果邻接节点正在访问中，说明存在环
                self.valid = False
                return
        self.visited[i] = 2  # 标记为访问完成

    # 主要思路：判断是否可以完成所有课程（即图中是否存在环）
    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
        # 初始化图结构（邻接表）
        self.graph = [[] for _ in range(numCourses)]
        for par in prerequisites:
            self.graph[par[1]].append(par[0])  # 课程 par[0] 依赖于 par[1]

        self.visited = [0] * numCourses  # 初始化所有节点为未访问状态
        for i in range(numCourses):
            if self.valid and self.visited[i] == 0:
                self.dfs(i)  # 从未访问的节点开始 DFS

        return self.valid  # 若无环，则返回 true；否则返回 false
基于 java 的代码实现

实现思路请参考前文，先理解思路再看代码。

这里强调一下：实际开发中，禁止使用行尾注释。这里是为了介绍算法参数，不想让代码很累赘

class Solution {
    private boolean valid = true;  // 标记是否有环，默认可以完成所有课程（无环）
    private int[] visited;  // 标记每个节点的访问状态：0 = 未访问，1 = 正在访问，2 = 已完成访问
    private List<List<Integer>> graph;  // 邻接表，表示课程之间的依赖图

    // 深度优先搜索判断是否存在环
    private void dfs(int i) {
        visited[i] = 1;  // 标记为正在访问中
        for (int v : graph.get(i)) {
            if (visited[v] == 0) {
                // 如果邻接节点未访问，继续 DFS
                dfs(v);
                if (!valid) return;  // 如果已经发现环，提前退出
            } else if (visited[v] == 1) {
                // 如果邻接节点正在访问中，说明存在环
                valid = false;
                return;
            }
        }
        visited[i] = 2;  // 标记为访问完成
    }

    // 主要思路：判断是否可以完成所有课程（即图中是否存在环）
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        // 初始化图结构（邻接表）
        graph = new ArrayList<>();
        for (int i = 0; i < numCourses; i++) {
            graph.add(new ArrayList<>());
        }
        for (int[] pair : prerequisites) {
            graph.get(pair[1]).add(pair[0]);  // 课程 pair[0] 依赖于 pair[1]
        }

        visited = new int[numCourses];  // 初始化所有节点为未访问状态
        for (int i = 0; i < numCourses && valid; i++) {
            if (visited[i] == 0) {
                dfs(i);  // 从未访问的节点开始 DFS
            }
        }

        return valid;  // 若无环，则返回 true；否则返回 false
    }
}

2.4 总结

力扣的这道题可以作为 拓扑排序 的 模板题，因为理解题目容易，必须建立在对 拓扑排序 的两种方法的了解的基础上，才能完成。中等难度，比较适合新手练习。

就题目而言，这道题本身就是判断是否有环的问题，通过拓扑排序实现而言。

继续强调一下，做题的目的是为了更加熟悉拓扑排序的算法思想，算法套路，不能停留在解决问题本身。

感谢各位小伙伴们的 阅读、点赞、评论 与 关注 ~ 希望本文能帮助到各位，共勉 ~

在这里插入图片描述

Smileyan
2025.04.12 19:04

Algorithm：【算法进阶之路】之算法面试刷题集合—数据结构知识和算法刷题及其平台、问题为导向的十大类刷题算法(数组和字符串、链表、栈和队列、二叉树、堆、图、哈希表、排序和搜索、回溯算法、枚举/递
头部AI社区如有邀博主AI主题演讲请私信—心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，专注，谦虚，自律，反思，成长，还算比较正能量的博主，公益免费传播…内心特别想在AI界做出一些可以推进历史进程影响力的技术(兴趣使然，有点小情怀，也有点使命感呀
04-22 1396
​ Algorithm：【算法进阶之路】之算法面试刷题集合—数据结构知识和算法刷题及其平台、问题为导向的十大类刷题算法(数组和字符串、链表、栈和队列、二叉树、堆、图、哈希表、排序和搜索、回溯算法、枚举/递归/分治/动态规划/贪心算法)总结 目录 相关文章 数据结构的最强学习路线之问题为导向的十大类刷题算法总结 一、学习相关的讲解与刷题平台 二、刷题集合 三、常见的十大类考试题型 相关文章 DSt：数据结构的简介、最强学习路线(逻辑结构【数组
【java】leetcode刷题记录+简单思路（hot100+剑指offer 简单\中等难度）
昂萨哈凯尔可真难记啊
08-14 1536
避免重复刷题每次都两眼一抹黑咩都不记得，简单记一下思路。 1. 两数之和（简单） 2. 两数相加（中等） 3. 无重复字符的最长子串（中等） 4. 寻找两个正序数组的中位数（困难） 5. 最长回文子串（中等） 10. 正则表达式匹配（困难） 11. 盛最多水的容器（中等） 15. 三数之和（中等） 17. 电话号码的字母组合（中等） 19. 删除链表的倒数第 N 个结点（中等） ...
拓扑排序(3/10) —— 力扣刷题 210. 课程表 II
Smileyan's blog
04-15 1149
拓扑排序第三章
力扣刷题汇总
想买很多漂亮衣服但是买不起的博客
01-17 473
力扣刷题汇总，分类别：动态规划，树，图，二分查找，指针，回溯，DFS，BFS等
C++刷题周记(三)——DFS/BFS/拓扑排序
funkoctopus的博客
05-16 437
本周将进入图论的学习，在此之前，我们需要了解dfs/bfs这两种经典的遍历方法。
LeetCode力扣刷题——指针三剑客之三：图
指北针_N的博客
11-19 861
图，图论，二分图，拓扑排序，最短路径。作为指针三剑客之三，图是树的升级版。图通常分为有向（directed）或无向（undirected），有 循环（cyclic）或无循环（acyclic），所有节点相连（connected）或不相连（disconnected）。树即是 一个相连的无向无环图，而另一种很常见的图是有向无环图（Directed Acyclic Graph，DAG）。有向无环图样例图通常有两种表示方法，邻接矩阵，邻接表（邻接链表）。
scala 刷LeetCode题——1462. 课程表 IV
XMZHSY的博客
10-23 334
采用拓扑排序和递归算法实现了先修课程的问题，语言是scala。
力扣刷题顺序，别人的引用一下
weixin_50517544的博客
03-13 875
题目分类及刷题顺序推荐 一. 数组 题目分类题目编号数组的遍历485 最大连续 1 的个数495 提莫攻击414 第三大的数628 三个数的最大乘积统计数组中的元素645 错误的集合697 数组的度448 找到所有数组中消失的数字442 数组中重复的数据41 缺失的第一个正数274 H 指数数组的改变、移动453 最小操作次数使数组元素相等665 非递减数列283 移动零二维数组及滚动数组118 杨辉三角119 杨辉三角 II661 图片平滑器598 范围求和 II419 甲板上的战舰数组的旋转189 轮转
【力扣热题100，个人刷题笔记---中】
weixin_45016269的博客
10-19 466
接上文，为力扣刷题个人笔记。
算法刷题(1)-----拓扑排序问题
qq_45329568的博客
04-05 362
@TOC 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matplotlib.p.
力扣LeetCode刷题笔记总结1
weixin_47887421的博客
04-09 877
题型一：数组 0.数组的基础知识 （1）数组下标都是从0开始的，数组内存空间的地址是连续的。因为数组的在内存空间的地址是连续的，所以我们在删除或者增添元素的时候，就难免要移动其他元素的地址。 （2）数组的元素是不能删的，只能覆盖。 （3）C++中，要注意vector 和 array的区别，vector的底层实现是array，严格来讲vector是容器，不是数组。 1.二分查找 解法1：左闭右闭的区间 定义target在[left, right]区间内，所以有如下两点： while (le
力扣500题刷题笔记10
08-04
力扣题目500题中的第10题主要涉及了...总结来说，力扣500题刷题笔记10主要涉及了图论中的拓扑排序，用于解决课程表问题，判断是否能按照依赖关系完成所有课程的学习。这个问题的关键在于理解和正确实现拓扑排序算法。
Leetcode Top100题目和答案（Java完整版 面试必备）
热门推荐
lx_lollipop的博客
03-26 9万+
最近忙着准备春招，复习完这个又复习那个。不过还是忙里偷闲，把剑指Offer这66道题目重新刷了一遍，收获还是很大的，下面贴出答案，又不懂的可以给我留言，博主会及时解答。 我的github 准备把春招复习的知识都整理到github上，一边是自己做个总结，一边也能供大家参考 ——leetcode数据库 19道题 ——剑指Offer 66道题 以下摘自leetcode Top100精选题目 文章目录1....
原创 | 初学者友好！最全算法学习资源汇总（附链接）
数据派THU
08-24 1751
在计算机发展飞速的今天，也许有人会问，“今天计算机这么快，算法还重要吗？”其实永远不会有太快的计算机，因为我们总会想出新的应用。虽然在摩尔定律的作用下，计算机的计算能力每年都在飞快增长，...
34.多点求均值的模拟信号抗干扰算法使用注意事项
最新发布
lc160809的博客
05-04 456
（3）服从正态分布和均匀分布的干扰信号适合用多点求均值滤波抗干扰。通过产品电路噪声分析或者电流钳配合示波器FFT得出。（3)连续采样的多个点数至少要覆盖一个噪声周期。可以通过产品功能分析得出，干扰频段f。（1）多点求均值滤波属于低通滤波器。至少要大于5倍的有用信号频率f。（2）实际每次采样要采样n个点。（2）有用信号的频率f。
C++基础算法9：Dijkstra
ccrr7的博客
05-04 603
Dijkstra求解路径最短问题
算法题（138）：在排序数组中查找元素的第一个和最后一个位置
2301_79954395的博客
05-04 453
若left等于right可以作为循环进行条件，那么我们要么会导致left>right，要么就陷入死循环（一直让right更新为mid，相当于没变），而陷入死循环是绝对不允许的。这里我们的right和left的差为3，为奇数，所以我们加一之后得到的索引为2，不加得到的索引为1，这就是前面说的，加一会让mid偏右一位，不加会偏左一位。当mid索引处的值大于等于target时，说明mid右边区域的值都可以从最小左边界中排除，让right指向mid索引的位置。不过他的时间复杂度就是O（n），不符合题目的要求。
关于离散化算法的看法与感悟
2301_81848095的博客
05-04 906
离散化本质上是一种数据压缩技术，它：将无限或大范围的连续数据映射到有限的小范围离散值保持原始数据的相对顺序关系减少数据的复杂度同时保留关键信息。
LeetCode 1128.等价多米诺骨牌对的数量：计数
<font color="Pink">Tisfy的博客</font>
05-04 1198
LeetCode 1128.等价多米诺骨牌对的数量：计数 给你一组多米诺骨牌 dominoes 。 形式上，dominoes[i] = [a, b] 与 dominoes[j] = [c, d] 等价 当且仅当 (a == c 且 b == d) 或者 (a == d 且 b == c) 。即一张骨牌可以通过旋转 0 度或 180 度得到另一张多米诺骨牌。 在 0 <= i < j
力扣刷题笔记.pdf
12-11
力扣刷题笔记.pdf是一份非常重要的学习资料，里面记录了刷力扣题目时的一些关键思路、解题方法和总结。在这份笔记中，可以记录下每道题的解法和思路，以及一些常见的错误和易错点。这样在以后复习和总结的时候，就可以及时查看自己的笔记，加深对知识点的理解和记忆。同时，这份笔记也是自己学习的一种反馈和总结，可以发现自己在刷题过程中的不足和提高的方向。 力扣刷题笔记.pdf还可以帮助自己更好地进行自我评估，查漏补缺。通过不断地总结和记录，可以帮助自己发现自己在哪些地方容易出错，哪些地方需要加强，以及以后如何更好地准备类似的题目。这样就可以在以后的刷题过程中避免同样的错误，提高自己的解题效率。 综合来看，力扣刷题笔记.pdf对于自己的学习和提高是非常重要的。通过不断地总结和记录，可以加深对知识点的理解、避免常见的错误、提高解题效率，从而帮助自己更好地提高自己的编程能力。因此，对于这份笔记要好好地珍惜和维护，不断地完善和更新，让它成为自己学习的助力，为自己的编程之路保驾护航。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

smile-yan

感谢您的支持！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值