Day90 课程表 II

最新推荐文章于 2024-07-27 13:01:20 发布

微光长明

最新推荐文章于 2024-07-27 13:01:20 发布

阅读量123

点赞数 1

分类专栏： LeetCode刷题集文章标签： leetcode java 算法 dfs

本文链接：https://blog.csdn.net/walkmanfy/article/details/116195126

版权

LeetCode刷题集专栏收录该内容

90 篇文章 0 订阅

订阅专栏

该博客讨论了如何使用深度优先搜索（DFS）解决LeetCode上的'课程表II'问题。博主分享了一种Java解决方案，该方案通过状态记录和回溯检查课程的先决条件，以确定学习课程的正确顺序。当遇到环状依赖时，算法会检测到并返回空数组。此外，博主还提到了官方解法，并建议可以尝试使用广度优先搜索（BFS）作为另一种可能的解决方案。

摘要由CSDN通过智能技术生成

##现在你总共有 n 门课需要选，记为 0 到 n-1。

在选修某些课程之前需要一些先修课程。例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们: [0,1]

给定课程总量以及它们的先决条件，返回你为了学完所有课程所安排的学习顺序。

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

https://leetcode-cn.com/problems/course-schedule-ii/

示例1：

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

示例2：

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

提示：

输入的先决条件是由边缘列表表示的图形，而不是邻接矩阵。详情请参见图的表示法。
你可以假定输入的先决条件中没有重复的边。
这个问题相当于查找一个循环是否存在于有向图中。如果存在循环，则不存在拓扑排序，因此不可能选取所有课程进行学习。
通过 DFS 进行拓扑排序 - 一个关于Coursera的精彩视频教程（21分钟），介绍拓扑排序的基本概念。
拓扑排序也可以通过 BFS 完成。

Java解法

思路：

之前做过Day82 课程表，这里参考同样的解法，通过深度搜索+回溯+状态记录来完成
状态记录当前位置是否被扫描过，已处理；处理中；未处理
对于访问已是处理中的情况，表明有环，不能完成学习
这里有个问题，上次是判断能不能遍历完成，这次要记录遍历顺序，有点逗比，考虑用hashmap分别记录不同结点遍历结束的情况，然而实际上不用这么操作，参考官方解，遍历到最后位置的结点，直接放入结果数组的最后结点即可

class Solution {

     List<List<Integer>> learnRule;
     int[] learnStatus; //0未处理;1处理中;2已处理
     int[] result;
     boolean canLearn = true;
    // 栈下标
     int index;
    public  int[] findOrder(int numCourses, int[][] prerequisites) {
        learnRule = new ArrayList<>();
        learnStatus = new int[numCourses];
        result = new int[numCourses];
        for (int i = 0; i < numCourses; i++) {
            learnRule.add(new ArrayList<>());
        }
        index = numCourses - 1;
        for (int[] prerequisite : prerequisites) {
            learnRule.get(prerequisite[1]).add(prerequisite[0]);
        }
        for (int i = 0; i < learnStatus.length && canLearn; i++) {
            if (learnStatus[i] == 0) {
                dfs(i);
            }
        }
        if (!canLearn) {
            return new int[0];
        }
        return result;
    }

    private  void dfs(int i) {
        learnStatus[i] = 1;
        //对i进行深度搜索
        for (Integer integer : learnRule.get(i)) {
            if (learnStatus[integer] == 1) {
                //有环
                canLearn = false;
                return;
            } else if(learnStatus[integer] == 0) {
                dfs(integer);
                if (!canLearn) {
                    return;
                }
            }
        }
        learnStatus[i] = 2;
        // 将节点入栈
        result[index--] = i;
    }
}