算法日记:leetcode 207 课程表

最新推荐文章于 2024-04-05 22:25:36 发布

二代熊猫超人

最新推荐文章于 2024-04-05 22:25:36 发布

阅读量96

点赞数

文章标签： leetcode 算法

本文链接：https://blog.csdn.net/lyb2021/article/details/125354507

版权

问题描述

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

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

例如，先修课程对 [0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1 。
请你判断是否可能完成所有课程的学习？如果可以，返回 true ；否则，返回 false 。

来源：力扣（LeetCode）
链接：207：课程表
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路分析

用例分析：当prerequisite[ ][ ] 出现闭环的情况，如[0][1] ,[1][0] 的情况，则说明本身是一个互相矛盾，形成一个闭环的问题，因此此时返回false；

因此从该思考点出发：是否将问题转化成（树、图）进行理解（判断图的拓扑排序的问题）

遍历树、图的概念，判断当前的结点是否被完全访问过。从而进行解决。

遍历图、树一类的问题：深度优先遍历、广度优先遍历

使用广度优先遍历的思想

（处理相关的结点，当入度为0的时候，进行节点的删除）

class Solution {
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        // 邻接表的思路的实现
        List<List<Integer>> adj = new ArrayList<>();
        Queue<Integer> queue = new LinkedList<>();
        int indegree [] =new int [numCourses];
        //对相应的桶进行处理
        for(int  i = 0;i<numCourses;i++){
            adj.add(new ArrayList<>());
        }
        //遍历prerequisite中的元素，将相应的前置和后置条件的结果填入
        for(int []arr : prerequisites){
            indegree[arr[0]]++;
            adj.get(arr[1]).add(arr[0]);
        }
        //就是前置的结点的删除（将删除的结点移动）(关键路径中没有前置结点（度为 0 点）)
        for(int i = 0;i<numCourses;i++){
            if(indegree[i] == 0){
                queue.add(i);
            }
        }
        //将相关的结点的子结点的入度删除
        while(!queue.isEmpty()){
            int pre = queue.poll();
            numCourses --;
            //将邻接表的相关元素进行删除
            for(int cur :adj.get(pre)){
                if(--indegree[cur] == 0){
                    queue.add(cur);
                }
            }
        }
        return numCourses == 0;
    }
}

总结：在实现的过程中，注意思想的转化以及相应的具体算法的实现（如了解并且接触过邻接表、关键路径方法的计算。但是在实际中，没有将其算法具体的实现）

深度优先遍历

class Solution {
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        // 基于图的实现的思路， 在结点的移出上面使用递归的深度优先遍历
            List<List<Integer>> adj = new ArrayList<>();
            int indegree [] = new int [numCourses];
            //填坑做表
            for(int i = 0;i<numCourses;i++){
                adj.add(new ArrayList<>());
            }
            for(int arr[] :prerequisites){
                adj.get(arr[1]).add(arr[0]);
            }
            //进行遍历
            for(int i = 0;i<numCourses;i++){
                if(!dfs(adj,i,indegree)){
                    return false;
                }
            }
            return true;
        }
        public boolean dfs(List<List<Integer>> adj,int i,int []indegree){
            if(indegree[i]== 1){
                return false;
            }   
            if(indegree[i] == -1){
                return true;
            }
            indegree[i] = 1;
            for(int cur :adj.get(i)){
                if(!dfs(adj,cur,indegree)){
                    return false;
                }
            }
            indegree[i] = -1;
            return true;
        }
    }

深度优先遍历的实现：主体逻辑上还是借助着领接表的逻辑但是在具体的细节处理上，没有在记录下每个结点的入度，而是考虑使用标记来标注结点是否处于一个可被删除的状态。

图中的结点一开始处于1状态，表示一个不可删除的状态。只有当邻接表中的子元素都处于一个可被删除的状态，才能将该结点进行删除操作。

因此此时的状态表示才可以修改成为-1，表示结点能够完全结束

因此是一个递归的深度优先操作。