题目及测试
package pid207;
/* 课程表
现在你总共有 n 门课需要选,记为 0 到 n-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。这是不可能的。
说明:
输入的先决条件是由边缘列表表示的图形,而不是邻接矩阵。详情请参见图的表示法。
你可以假定输入的先决条件中没有重复的边。
提示:
这个问题相当于查找一个循环是否存在于有向图中。如果存在循环,则不存在拓扑排序,因此不可能选取所有课程进行学习。
通过 DFS 进行拓扑排序 - 一个关于Coursera的精彩视频教程(21分钟),介绍拓扑排序的基本概念。
拓扑排序也可以通过 BFS 完成。
*/
public class main {
public static void main(String[] args) {
int testTable1= 2;
int[][] testTable2 = {{1,0}};
//int[][] testTable2 = {{1,0},{0,1}};
test(testTable1,testTable2);
}
private static void test(int ito,int[][] ito2) {
Solution solution = new Solution();
boolean rtn;
long begin = System.currentTimeMillis();
System.out.println("ito1="+ito);
for (int i = 0; i < ito2.length; i++) {
for (int j = 0; j < ito2[i].length; j++) {
System.out.print(ito2[i][j]+" ");
}
System.out.println();
}
System.out.println();
//开始时打印数组
rtn = solution.canFinish(ito,ito2);//执行程序
long end = System.currentTimeMillis();
System.out.println("rtn=" +rtn);
System.out.println();
System.out.println("耗时:" + (end - begin) + "ms");
System.out.println("-------------------");
}
}
没想出来
解法1(别人的)
本题可约化为:课程安排图是否是 有向无环图(DAG)。即课程间规定了前置条件,但不能构成任何环路,否则课程前置条件将不成立。
思路是通过 拓扑排序 判断此课程安排图是否是 有向无环图(DAG)。
拓扑排序是对 DAG 的顶点进行排序,使得对每一条有向边 (u,v),均有 u(在排序记录中)比 v先出现。亦可理解为对某点 v而言,只有当 v的所有源点均出现了,v才能出现。
通过课程前置条件列表 prerequisites 可以得到课程安排图的 邻接矩阵 adjacency,以下两种方法都会用到邻接矩阵。
入度表(广度优先遍历)
统计课程安排图中每个节点的入度,生成 入度表 indegrees。
借助一个队列 queue,将所有入度为 0的节点入队。
当 queue 非空时,依次将队首节点出队,在课程安排图中删除此节点 pre:
并不是真正从邻接表中删除此节点 pre,而是将此节点对应所有邻接节点 cur 的入度 −1,即 indegrees[cur] -= 1。
当入度 −1后邻接节点 cur 的入度为 0,说明 cur 所有的前驱节点已经被 “删除”,此时将 cur 入队。
在每次 pre 出队时,执行 numCourses--;
若整个课程安排图是有向无环图(即可以安排),则所有节点一定都入队并出队过,即完成拓扑排序。换个角度说,若课程安排图中存在环,一定有节点的入度始终不为 0。
因此,拓扑排序出队次数等于课程个数,返回 numCourses == 0 判断课程是否可以成功安排。
时间复杂度 O(N+M),遍历一个图需要访问所有节点和所有临边,N 和 M分别为节点数量和临边数量;
空间复杂度 O(N),为建立邻接矩阵所需额外空间。
class Solution {
public boolean canFinish(int numCourses, int[][] prerequisites) {
int[] indegrees = new int[numCourses];
for(int[] cp : prerequisites) indegrees[cp[0]]++;
LinkedList<Integer> queue = new LinkedList<>();
for(int i = 0; i < numCourses; i++){
if(indegrees[i] == 0) queue.addLast(i);
}
while(!queue.isEmpty()) {
Integer pre = queue.removeFirst();
numCourses--;
for(int[] req : prerequisites) {
if(req[1] != pre) continue;
if(--indegrees[req[0]] == 0) queue.add(req[0]);
}
}
return numCourses == 0;
}
}
解法2(别人的)
深度优先遍历
借助一个标志列表 flags,用于判断每个节点 i (课程)的状态:
未被 DFS 访问:i == 0;
已被其他节点启动的DFS访问:i == -1;
已被当前节点启动的DFS访问:i == 1。
对 numCourses 个节点依次执行 DFS,判断每个节点起步 DFS 是否存在环,若存在环直接返回 False。DFS 流程;
终止条件:
当 flag[i] == -1,说明当前访问节点已被其他节点启动的 DFS 访问,无需再重复搜索,直接返回 True。
当 flag[i] == 1,说明在本轮 DFS 搜索中节点 i 被第 2次访问,即 课程安排图有环,直接返回 False。
将当前访问节点 i 对应 flag[i] 置 1,即标记其被本轮 DFS 访问过;
递归访问当前节点 i 的所有邻接节点 j,当发现环直接返回 False;
当前节点所有邻接节点已被遍历,并没有发现环,则将当前节点 flag 置为 −1 并返回 True。
若整个图 DFS 结束并未发现环,返回 True。
class Solution {
public boolean canFinish(int numCourses, int[][] prerequisites) {
int[][] adjacency = new int[numCourses][numCourses];
int[] flags = new int[numCourses];
for(int[] cp : prerequisites)
adjacency[cp[1]][cp[0]] = 1;
for(int i = 0; i < numCourses; i++){
if(!dfs(adjacency, flags, i)) return false;
}
return true;
}
private boolean dfs(int[][] adjacency, int[] flags, int i) {
if(flags[i] == 1) return false;
if(flags[i] == -1) return true;
flags[i] = 1;
for(int j = 0; j < adjacency.length; j++) {
if(adjacency[i][j] == 1 && !dfs(adjacency, flags, j)) return false;
}
flags[i] = -1;
return true;
}
}
解法3(成功,6ms,较慢)
public class Solution {
public boolean canFinish(int numCourses, int[][] prerequisites) {
if(numCourses == 0|| numCourses == 1) {
return true;
}
if(prerequisites.length == 0) {
return true;
}
int[] arrayIn = new int[numCourses];
HashMap<Integer, Set<Integer>> map = new HashMap<Integer, Set<Integer>>();
for(int[] array:prerequisites) {
int from = array[1];
int to = array[0];
arrayIn[to]++;
Set<Integer> set = map.get(from);
if(set == null) {
set = new HashSet<Integer>();
}
set.add(to);
map.put(from, set);
}
while(true) {
int now = -1;
for(int i = 0;i<numCourses;i++) {
if(arrayIn[i] == 0) {
now = i;
break;
}
}
if(now == -1) {
break;
}
arrayIn[now] = -1;
Set<Integer> set = map.get(now);
if(set == null) {
continue;
}
for(Integer to:set) {
arrayIn[to]--;
}
}
for(int i = 0;i<numCourses;i++) {
if(arrayIn[i] >= 0) {
return false;
}
}
return true;
}
}