LeetCode题练习与总结：课程表Ⅱ--210

一直学习永不止步

于 2024-08-29 09:00:00 发布

阅读量732

点赞数 24

分类专栏： LeetCode Java 中等文章标签：数据结构 LeetCode Java 深度优先搜索广度优先搜索图拓扑排序

本文链接：https://blog.csdn.net/weixin_62860386/article/details/141338062

版权

LeetCode 同时被 3 个专栏收录

242 篇文章 0 订阅

订阅专栏

Java

227 篇文章 0 订阅

订阅专栏

中等

137 篇文章 0 订阅

订阅专栏

一、题目描述

现在你总共有 numCourses 门课需要选，记为 0 到 numCourses - 1。给你一个数组 prerequisites ，其中 prerequisites[i] = [ai, bi] ，表示在选修课程 ai 前必须先选修 bi 。

例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示：[0,1] 。

返回你为了学完所有课程所安排的学习顺序。可能会有多个正确的顺序，你只要返回 任意一种 就可以了。如果不可能完成所有课程，返回 一个空数组 。

示例 1：

输入：numCourses = 2, prerequisites = [[1,0]]
输出：[0,1]
解释：总共有 2 门课程。要学习课程 1，你需要先完成课程 0。因此，正确的课程顺序为 [0,1] 。

示例 2：

输入：numCourses = 4, prerequisites = [[1,0],[2,0],[3,1],[3,2]]
输出：[0,2,1,3]
解释：总共有 4 门课程。要学习课程 3，你应该先完成课程 1 和课程 2。并且课程 1 和课程 2 都应该排在课程 0 之后。
因此，一个正确的课程顺序是 [0,1,2,3] 。另一个正确的排序是 [0,2,1,3] 。

示例 3：

输入：numCourses = 1, prerequisites = []
输出：[0]

提示：

1 <= numCourses <= 2000
0 <= prerequisites.length <= numCourses * (numCourses - 1)
prerequisites[i].length == 2
0 <= ai, bi < numCourses
ai != bi
所有[ai, bi] 互不相同

二、解题思路

这个问题可以通过拓扑排序来解决。拓扑排序是针对有向无环图（DAG）的一种排序算法，它会返回一个顶点的线性序列，这个序列满足图中所有的有向边都从序列的前面指向后面。

以下是解题思路：

创建一个入度数组，用于记录每个顶点的入度（即有多少边指向它）。
创建一个队列，用于存储所有入度为0的顶点（这些顶点没有先修课程，可以立即学习）。
当队列非空时，从队列中弹出一个顶点，将该顶点添加到结果列表中，并减少其所有邻接顶点的入度。如果某个邻接顶点的入度变为0，则将其加入队列。
如果结果列表中的顶点数量等于课程数，则返回结果列表；否则，说明存在环，返回空数组。

三、具体代码

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

public class Solution {
    public int[] findOrder(int numCourses, int[][] prerequisites) {
        // 1. 创建入度数组
        int[] inDegree = new int[numCourses];
        // 2. 创建邻接表
        List<List<Integer>> adjList = new ArrayList<>(numCourses);
        for (int i = 0; i < numCourses; i++) {
            adjList.add(new ArrayList<>());
        }
        // 3. 填充入度数组和邻接表
        for (int[] prerequisite : prerequisites) {
            inDegree[prerequisite[0]]++;
            adjList.get(prerequisite[1]).add(prerequisite[0]);
        }
        // 4. 创建队列，存储所有入度为0的顶点
        Queue<Integer> queue = new LinkedList<>();
        for (int i = 0; i < numCourses; i++) {
            if (inDegree[i] == 0) {
                queue.offer(i);
            }
        }
        // 5. 拓扑排序
        int[] order = new int[numCourses];
        int index = 0;
        while (!queue.isEmpty()) {
            int current = queue.poll();
            order[index++] = current;
            for (int next : adjList.get(current)) {
                inDegree[next]--;
                if (inDegree[next] == 0) {
                    queue.offer(next);
                }
            }
        }
        // 6. 检查是否所有课程都被安排了
        if (index == numCourses) {
            return order;
        } else {
            return new int[0]; // 如果存在环，返回空数组
        }
    }
}

四、时间复杂度和空间复杂度

1. 时间复杂度

初始化入度数组和邻接表：我们需要遍历所有课程（numCourses），并初始化每个课程的入度数组和邻接表。这一步的时间复杂度是 O(numCourses)。
填充入度数组和邻接表：我们需要遍历所有的先修课程（prerequisites），对于每个先修课程对，我们需要更新入度数组和邻接表。这一步的时间复杂度是 O(prerequisites.length)。
将所有入度为0的课程加入队列：我们需要再次遍历所有课程，检查每个课程的入度。这一步的时间复杂度是 O(numCourses)。
进行拓扑排序：在拓扑排序过程中，每个课程最多只会被添加到队列一次，并且从队列中移除一次。因此，这一步的时间复杂度是 O(numCourses + prerequisites.length)，因为每个先修课程对都会被访问一次。

综上所述，总的时间复杂度是 O(numCourses + prerequisites.length)。

2. 空间复杂度

入度数组：我们创建了一个大小为 numCourses 的数组来存储每个课程的入度。因此，空间复杂度是 O(numCourses)。
邻接表：邻接表中的每个课程最多会有 numCourses - 1 个邻接课程（在最坏的情况下，每个课程都依赖于其他所有课程）。因此，邻接表的空间复杂度是 O(numCourses * (numCourses - 1))。
队列：在最坏的情况下，队列可能需要存储所有课程，因此空间复杂度是 O(numCourses)。
结果数组：结果数组的大小是 numCourses，因此空间复杂度是 O(numCourses)。

将上述空间复杂度相加，我们得到总的空间复杂度是 O(numCourses + numCourses * (numCourses - 1))，即 O(numCourses^2)。在最坏的情况下，这个表达式可以简化为 O(numCourses^2)，因为当 numCourses 较大时，numCourses^2 将是主导项。然而，在实际情况下，由于每个课程不可能都依赖于其他所有课程，因此实际的空间复杂度通常会小于这个上限。