拓扑排序
求拓扑序
拓扑排序成立的条件是图中没有环
207. 课程表 mid
你这个学期必须选修 numCourses 门课程,记为 0 到 numCourses - 1。
在选修某些课程之前需要一些先修课程。 先修课程按数组 prerequisites 给出,其中 prerequisites[i] = [ai, bi],表示如果要学习课程 ai 则 必须 先学习课程 bi。
- 例如,先修课程对 [0, 1] 表示:想要学习课程 0,你需要先完成课程 1。
请你判断是否可能完成所有课程的学习?如果可以,返回 true;否则,返回 false。
先初始化临接表, 然后 BFS/DFS
解法 1 DFS
遍历每个节点, 每个节点有 3 种状态(没学过, 学习中, 学完了), 如果发现后修课程在学习中, 则不成立
2 种状态为什么不行, 因为学完的不用再学,遍历的时候有些后修课程会先修(不影响结果)
java
class Solution {
// 邻接表, idx=先修课程,arr[idx]=后修课程; 本质是边的集合
List<Integer>[] edges;
// 入度
int[] visit;
boolean valid = true;
public boolean canFinish(int numCourses, int[][] prerequisites) {
visit = new int[numCourses];
@SuppressWarnings({"unchecked"})
List<Integer>[] arr = new List[numCourses];
edges = arr;
// 有可能有单节点, 不能懒加载
for (int i = 0; i < numCourses; ++i) {
edges[i] = new ArrayList<>();
}
for (int[] e : prerequisites) {
// 先修e[1] 后修e[0]
edges[e[1]].add(e[0]);
}
//============ 初始化结束 ============
// 遍历所有节点
for (int i = 0; valid && i < numCourses; ++i) {
if (visit[i] == 0) dfs(i);
}
return valid;
}
public void dfs(int idx) {
// 学习中
visit[idx] = -1;
for (int after : edges[idx]) {
if (visit[after] == 0) dfs(after);
else if (visit[after] == -1) valid = false;
if (!valid) return;
}
// 学习完成
visit[idx] = 1;
}
}
解法 2 BFS
BFS 从入度为 0 的节点开始, 将临接点的入度-1 后, 如果入度为 0, 加入 que
判定: 处理过的节点数量 == num
java
class Solution {
// 邻接表, idx=先修课程,arr[idx]=后修课程; 本质是边的集合
List<Integer>[] edges;
// 入度
int[] in;
public boolean canFinish(int numCourses, int[][] prerequisites) {
in = new int[numCourses];
@SuppressWarnings({"unchecked"})
List<Integer>[] arr = new List[numCourses];
edges = arr;
// 有可能有单节点, 不能懒加载
for (int i = 0; i < numCourses; ++i) {
edges[i] = new ArrayList<>();
}
for (int[] e : prerequisites) {
// 先修e[1] 后修e[0]
in[e[0]]++;
edges[e[1]].add(e[0]);
}
//============ 初始化结束 ============
Queue<Integer> queue = new ArrayDeque<>();
for (int i = 0; i < numCourses; i++) {
if (in[i] == 0) queue.add(i);
}
// 环中的节点入度>0
int cnt = numCourses;
while (!queue.isEmpty()) {
Integer e = queue.remove();
cnt--;
for (Integer after : edges[e]) {
if (--in[after] == 0) queue.add(after);
}
}
return cnt == 0;
}
}
210. 课程表 II mid
剑指 Offer II 113. 课程顺序
现在你总共有 numCourses 门课需要选,记为 0 到 numCourses - 1。给你一个数组 prerequisites,其中 prerequisites[i] = [ai, bi],表示在选修课程 ai 前必须先选修 bi。
- 例如,想要学习课程 0,你需要先完成课程 1,我们用一个匹配来表示:[0,1]。
返回你为了学完所有课程所安排的学习顺序。可能会有多个正确的顺序,你只要返回 任意一种 就可以了。如果不可能完成所有课程,返回一个空数组。
BFS
入度为 0 开始
java
class Solution {
public int[] findOrder(int num, int[][] prerequisites) {
@SuppressWarnings("unchecked")
List<Integer>[] edgeList = new List[num];
for (int i = 0; i < num; i++) {
edgeList[i] = new ArrayList<>();
}
int[] in = new int[num];
// 先修e[1] 后修e[0]
for (int[] e : prerequisites) {
edgeList[e[1]].add(e[0]);
in[e[0]]++;
}
Queue<Integer> que = new ArrayDeque<>();
for (int i = 0; i < in.length; i++) {
if (in[i] == 0) que.add(i);
}
int cnt = 0;
int[] res = new int[num];
while (!que.isEmpty()) {
Integer i = que.remove();
res[cnt++] = i;
for (Integer ii : edgeList[i]) {
if (--in[ii] == 0) que.add(ii);
}
}
return cnt < num ? new int[]{} : res;
}
}
DFS
后修课程一定在后面, dfs 倒序填入
java
class Solution {
boolean valid = true;
int idx;
public int[] findOrder(int num, int[][] prerequisites) {
@SuppressWarnings("unchecked")
List<Integer>[] edgeList = new List[num];
for (int i = 0; i < num; i++) {
edgeList[i] = new ArrayList<>();
}
// 先修e[1] 后修e[0]
for (int[] e : prerequisites) {
edgeList[e[1]].add(e[0]);
}
int[] visit = new int[num];
int[] res = new int[num];
idx = num - 1;
for (int i = 0; i < num && valid; i++) {
if (visit[i] == 0) dfs(edgeList, visit, res, i);
}
return valid ? res : new int[]{};
}
private void dfs(List<Integer>[] edgeList, int[] visit, int[] res, int i) {
// 搜索中
visit[i] = -1;
for (int e : edgeList[i]) {
if (visit[e] == 0)
dfs(edgeList, visit, res, e);
else if (visit[e] == -1) {
valid = false;
return;
}
}
// 倒序
res[idx--] = i;
visit[i] = 1;
}
}