【刷题1】LeetCode 207. 课程表 java题解

原创已于 2024-03-01 20:57:30 修改 · 698 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#数据结构 #算法 #java #dfs #bfs

于 2020-11-21 08:56:06 首次发布

LeetCode 专栏收录该内容

325 篇文章

订阅专栏

本文针对课程安排问题，提出两种解决方案：深度优先搜索（DFS）和广度优先搜索（BFS）。通过对课程之间的前置条件分析，利用拓扑排序来判断是否能顺利完成所有课程。

数据结构学的烂这都是数据结构留下的坑
至今还未重新学习数据结构看到一题算一题
太难了吧

1.题目

https://leetcode-cn.com/problems/course-schedule/
在这里插入图片描述

2.相关概念

入度：它通常指有向图中某点作为图中边的终点的次数之和。
** 边缘列表**：
在这里插入图片描述
邻接表：储存跟一个顶点相连的顶点

3.分析

课程安排图是否是有向无环图(DAG)。
即课程间规定了前置条件，但不能构成任何环路，否则课程前置条件将不成立。
思路是通过拓扑排序判断此课程安排图是否是有向无环图(DAG) 。拓扑排序原理：对 DAG 的顶点进行排序，使得对每一条有向边 (u, v)，均有u（在排序记录中）比 v先出现。亦可理解为对某点 v 而言，只有当 v 的所有源点均出现了，v 才能出现。
通过课程前置条件列表 prerequisites 可以得到课程安排图的邻接表，以降低算法时间复杂度。

4.方法一：dfs

分析

1.设置一个flag数组，用来判断每个节点i的状态
1）flag=0，未被访问过
2）flag=-1,被其他节点启动的dfs访问
3）flag=1,被当前节点启动的dfs访问
2.对numCourse个节点依次启动dfs，判读每个节点起步dfs是否存在环，若存在环直接返回false。

dfs:
1.终止条件：
flag=-1，被其他节点启动的dfs访问，直接返回true;
flag=1,已被当前节点启动的dfs访问过，返回false。
2.将flag置为1.
3.递归访问当前节点i的所有邻接节点j，当发现环直接返回false。
4.当前节点所有邻接节点已被遍历，并没有发现环，则将当前节点flag置为-1并返回true。

复杂度

时间复杂度O(m+n)：遍历一个图需要访问所有节点和邻边,nm分别为节点和邻边数量
空间复杂度O(m+n)：为建立邻接表所需额外空间,adjacency长度为n,并存储m条邻边的数据

代码

class Solution {
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        ArrayList<ArrayList<Integer>> list=new ArrayList<>(numCourses);//邻接表
        int[] flag=new int[numCourses];//标记数组
        for(int i=0;i<numCourses;i++){
            list.add(new ArrayList<Integer>());
        }
        for(int[] cp:prerequisites){
            //在第cp[1]个列表中加入cp[0]
            list.get(cp[1]).add(cp[0]);
        }
        for(int i=0;i<numCourses;i++){
            if(!dfs(list,flag,i))
                return false;
        }
        return true;
    }
    public boolean dfs(ArrayList<ArrayList<Integer>> list,int[] flag,int i){
        if(flag[i]==-1)
            return true;
        if(flag[i]==1)
            return false;
        flag[i]=1;
        for(int j:list.get(i)){
            if(!dfs(list,flag,j))
                return false;
        }
        flag[i]=-1;
        return true;
    }
}

结果

在这里插入图片描述

方法二：bfs

分析

1.统计课程安排图中每个节点的入度，生成入度表indegrees。
2.借助一个队列queue，将所有入度为0的节点入队。
3.当queue非空时，依次将队首节点pre出队。将此节点对应所有邻接节点cur的入度-1。如果-1后入度为0，入队。
4.在每次pre出队时，执行numCourses–。
若是有向无环图，则所有节点都一定入队并出队过，最后numCourses结果为0。

代码

class Solution {
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        ArrayList<ArrayList<Integer>> list=new ArrayList<>(numCourses);//邻接表
        int[] indegrees=new int[numCourses];//入度表
        for(int i=0;i<numCourses;i++){
            list.add(new ArrayList<Integer>());
        }
        for(int[] cp:prerequisites){
            indegrees[cp[0]]++;//入度+1
            list.get(cp[1]).add(cp[0]);//cp[1]->cp[0]
        }
        LinkedList<Integer> queue=new LinkedList<>();
        for(int i=0;i<numCourses;i++){
            if(indegrees[i]==0)
                queue.add(i);
        }
        while(!queue.isEmpty()){
            Integer pre=queue.poll();
            for(Integer i:list.get(pre)){//以pre为起点的，终点的入度表都-1
                indegrees[i]--;
                if(indegrees[i]==0)
                    queue.add(i);
            }
            numCourses--;
        }
        return numCourses==0?true:false;
    }
}

复杂度

结果

在这里插入图片描述

bfs解法，拓扑排序

//先修课程对 [0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1 
class Solution {
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        List<List<Integer>> edges=new ArrayList<List<Integer>>(numCourses);
        for(int i=0;i<numCourses;i++){
            edges.add(new ArrayList<Integer>());
        }
        //list.get(i)={i指向的节点}
        int[] ine=new int[numCourses];//各个节点的入度数量
        for(int i=0;i<prerequisites.length;i++){//遍历每一对节点，每一条边
            int a=prerequisites[i][0];
            int b=prerequisites[i][1];//1指向0
            ine[a]++;
            edges.get(b).add(a);
        }
        LinkedList<Integer> queue=new LinkedList<>();
        for(int i=0;i<numCourses;i++){
            if(ine[i]==0){
                queue.addLast(i);
            }
        }
        int visited=0;
        while(queue.size()!=0){
            visited++;
            int node=queue.removeFirst();//队列是先进先出的
            for(Integer n:edges.get(node)){
                ine[n]--;//减少入边
                if(ine[n]==0){//入度为0
                    queue.addLast(n);
                }
            }
            edges.get(node).clear();
            //edges.get(node)=new ArrayList<Integer>();//清空他对别人的指向
        }
        return visited==numCourses;//是否每个都入度为0
    }
}