算法-图-课程表
1 题目概述
1.1 题目出处
https://leetcode-cn.com/problems/course-schedule
1.2 题目描述
你这个学期必须选修 numCourse 门课程，记为 0 到 numCourse-1 。
在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们：[0,1]
给定课程总量以及它们的先决条件，请你判断是否可能完成所有课程的学习？
示例 1:
输入: 2, [[1,0]]
输出: true
解释: 总共有 2 门课程。学习课程 1 之前，你需要完成课程 0。所以这是可能的。
示例 2:
输入: 2, [[1,0],[0,1]]
输出: false
解释: 总共有 2 门课程。学习课程 1 之前，你需要先完成课程 0；并且学习课程 0 之前，你还应先完成课程 1。这是不可能的。
提示：
- 输入的先决条件是由 边缘列表 表示的图形，而不是 邻接矩阵 。详情请参见图的表示法。
- 你可以假定输入的先决条件中没有重复的边。
- 1 <= numCourses <= 10^5
2 图-DFS
2.1 思路
将所有课程作为有向图，那么要判断是否不能完成课程，就是判断是否存在循环依赖的课程，即图论中说的有环。
- 先计算出课程和所有后置课程对应关系
- 要DFS遍历有向图时，如果该轮递归中发现又回到本节点，则说明有环，不能完成课程。
2.2 代码
class Solution {
// key为某个课程，List为该课程的后置课程
private Map<Integer,List> courseMap = new HashMap<>();
public boolean canFinish(int numCourses, int[][] prerequisites) {
if(numCourses == 0){
return false;
}
if(prerequisites == null || prerequisites.length == 0) {
return true;
}
// 计算出课程和所有后置课程对应关系
for(int i = 0; i < prerequisites.length; i++){
int[] prerequisite = prerequisites[i];
int cur = prerequisite[0];
if(prerequisite.length == 1){
// 表示cur没有后置课程
courseMap.put(cur, null);
}else{
// 将cur课程设为其他前置课程的后置课程
for(int j = 1; j < prerequisite.length; j++){
List<Integer> cList = courseMap.get(prerequisite[j]);
if(cList == null){
cList = new ArrayList<Integer>();
courseMap.put(prerequisite[j], cList);
}
cList.add(cur);
}
}
}
// 记录每个节点是否已访问过
int[] visit = new int[numCourses];
// 只要DFS遍历有向图时，如果该轮递归中发现又回到本节点，则说明有环，不能完成课程。
Set<Integer> courseSet = courseMap.keySet();
// 遍历所有课程
for(int course : courseSet){
if(visit[course] == 1){
continue;
}
if(dag(new HashSet<Integer>(), course, visit)){
return false;
}
}
return true;
}
private boolean dag(Set<Integer> courses, int course, int[] visit){
// 标记已经遍历过该节点
visit[course] = 1;
// 获取该节点对应的所有后置课程列表
List<Integer> cList = courseMap.get(course);
if(cList == null){
// 没有后置依赖课程，则说明当前节点无环
return false;
}
// 将本节点记录到这趟递归的Set中
courses.add(course);
// 遍历该课程对应的所有后置课程列表
for(int c : cList){
if(courses.contains(c)){
// 如果该趟递归已经遇到过本节点临接的后置课程节点时，说明有环，返回true
return true;
}
if(visit[c] == 1){
// 已经遍历过的且不是本趟递归的节点不再遍历，因为是DFS所以肯定不会因为该节点形成环
continue;
}
if(dag(courses, c, visit)){
// 继续DFS递归本节点临接的其他节点，发现环就返回true
return true;
}
}
// 本次递归完成，需要返回给上一层递归时，需要从递归Set中移除本节点
// 否则可能造成本趟递归的另一次dfs遇到已经访问过的后置课程节点误判断为有环
// 说白了，判断有环的依据是一直dfs递归，直到无后置课程节点或遇到了这趟dfs递归中已访问过的节点，代表有环
// 只要回退到上一层，说明该趟dfs无环，所以需要先将该节点从已访问记录中删除
courses.remove(course);
// 表明本次递归无环（不代表本趟递归无环）
return false;
}
}
2.3 时间复杂度
O(V*E)
- 每个顶点V遍历一次，还需要判断所有临边
2.4 空间复杂度
最坏O(N^2)
- courseMap存储每个课程对应的后置List
3 图-DFS-优化1
3.1 思路
前面需要Set来存储该趟遍历访问过的节点，其实脑袋转一下，直接通过visit数组，不过加一个状态：
- 0表示未访问该节点
- 1表示该趟DFS正在访问该节点
- 2表示该趟遍历完成，该节点访问完毕
同时，我们将HashMap courseMap替换为ArrayList courseList，因为List直接直接定位无需计算hashcode、不会冲突等，所以这里效率更高。
3.2 代码
class Solution {
private List<List<Integer>> courseList = new ArrayList<>();
public boolean canFinish(int numCourses, int[][] prerequisites) {
if(numCourses == 0){
return false;
}
if(prerequisites == null || prerequisites.length == 0) {
return true;
}
for(int i = 0; i < numCourses; i++)
courseList.add(new ArrayList<>());
// 计算出课程和所有后置课程对应关系
for(int i = 0; i < prerequisites.length; i++){
int[] prerequisite = prerequisites[i];
if(prerequisite.length != 1){
courseList.get(prerequisite[1]).add(prerequisite[0]);
}
}
int[] visit = new int[numCourses];
// 只要DFS遍历有向图时，如果该轮递归中发现又回到本节点，则说明有环，不能完成课程。
for(int i = 0; i < numCourses; i++){
if(visit[i] == 2){
// 已经访问完毕的节点不再访问
continue;
}
if(dag(i, visit)){
return false;
}
}
return true;
}
private boolean dag(int course, int[] visit){
// 标记本趟递归正在访问该节点
visit[course] = 1;
// 获取该节点对应的所有后置依赖课程列表
List<Integer> cList = courseList.get(course);
if(cList == null){
// 没有后置依赖课程，则说明当前节点无环
// 记得标记本节点已经完成访问
visit[course] = 2;
return false;
}
for(int c : cList){
if(visit[c] == 2){
// 已经遍历过的且不是本趟递归的节点不再遍历，因为是DFS所以肯定不会因为该节点形成环
continue;
}
if(visit[c] == 1){
// 如果该趟递归已经遇到过本节点临接的后置节点时，说明有环，返回true
return true;
}
if(dag(c, visit)){
// 继续DFS递归本节点临接的其他节点，发现环就返回true
return true;
}
}
// 本次递归完成，标记本节点已经完成访问
visit[course] = 2;
// 表明本次递归无环（不代表本趟递归）
return false;
}
}
3.3 时间复杂度
O(V*E)
- 每个顶点V遍历一次，还需要判断所有临边
3.4 空间复杂度
最坏O(N^2)
- courseList存储每个课程对应的后置List
4 图-BFS
4.1 思路
计算每个节点入度，将入度为0的入队，表示没有前置课程。
同时广度优先方式遍历，将下游节点入度减一，如果入度为0也入队。
从队列里不停poll出首元素，直到队列为空。
如果最终队列为空后，poll出的元素数量少于原始节点数量，则代表存在环，使得入度不为0，选课失败。
否则选课成功。
4.2 代码
class Solution {
public boolean canFinish(int numCourses, int[][] prerequisites) {
if(numCourses == 0){
return false;
}
if(prerequisites == null || prerequisites.length == 0) {
return true;
}
List<List<Integer>> courseList = new ArrayList<>();
for(int i = 0; i < numCourses; i++)
courseList.add(new ArrayList<>());
// 记录每个节点的入度
int[] indegree = new int[numCourses];
// 计算出课程和所有后置课程对应关系
// 并计算入度
for(int i = 0; i < prerequisites.length; i++){
int[] prerequisite = prerequisites[i];
indegree[prerequisite[0]] ++;
courseList.get(prerequisite[1]).add(prerequisite[0]);
}
LinkedList<Integer> queue = new LinkedList<>();
for(int i = 0; i < numCourses; i++){
if(indegree[i] == 0){
// 将入度为0的课程全部放入队列待遍历
queue.add(i);
}
}
int count = bfs(courseList, queue, indegree, numCourses);
if(count > 0){
// 表示有入度不为0的课程，则存在环！
return false;
}
return true;
}
private int bfs(List<List<Integer>> courseList, LinkedList<Integer> queue, int[] indegree, int numCourses){
// 遍历入度为0的队列进行BFS
while(queue.size() > 0){
// 已经确定能选的课程数，减1
numCourses--;
// 从队列中取出一个入度为0的课程
int course = queue.poll();
// 得到后置课程
List<Integer> cList = courseList.get(course);
// 因为要模拟删除当前课程节点course，所以将course的后置课程入度减1，
// 若结果为0，则表示入度降为0，将该后置课程放入队列中
for(int c : cList){
if(--indegree[c] == 0){
queue.add(c);
}
}
}
// 最后返回入度不为0的课程数
return numCourses;
}
}
4.3 时间复杂度
O(V*E)
- 每个顶点V遍历一次，还需要判断所有临边
4.4 空间复杂度
最坏O(N^2)
- courseList存储每个课程对应的后置List
扫一扫
859
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
