Skip to content

拓扑排序

求拓扑序

拓扑排序成立的条件是图中没有环

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;
    }
}