LeetCode刷题笔记 207（涉及到拓扑排序）

题目：课程表

答案：

通过 拓扑排序 判断此课程安排图是否是 有向无环图(DAG)
拓扑排序是对 DAG 的顶点进行排序，使得对每一条有向边 (u, v)，均有 u（在排序记录中）比 v 先出现。

首先明确思路：每一个顶点都有入度和出度，入度为0说明没有指向它的，那么就从它开始往下找。
（1）将入度为0的顶点m（及其关联边）从图G中取出，则剩余的G’依然是有向无环图。
（2）重新考量图G’，重复（1）步骤，直到所有顶点均被取出。

1.广度优先遍历

（1）在开始排序前，扫描对应的存储空间（使用邻接表），将入度为0的结点放入队列。
（2）只要队列非空，就从队首取出入度为 0 的结点，count+1，并且将这个结点的所有邻接结点（它指向的结点）的入度减 1，在减 1 以后，如果这个被减 1 的结点的入度为 0 ，就继续入队。
（3）当队列为空的时候，检查count是否和课程数相等即可。

class Solution {
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        // 特判
        if (numCourses <= 0) return false;
        if (prerequisites.length == 0) return true;

        int[] inDegree = new int[numCourses];
        for(int[] cp : prerequisites) inDegree[cp[0]]++;

        Queue<Integer> queue = new LinkedList<>();

        // 首先加入入度为 0 的结点
        for (int i = 0; i < numCourses; i++) {
            if (inDegree[i] == 0) queue.add(i);
        }

        // 记录已经出队的课程数量
        int cnt = 0;
        while (!queue.isEmpty()) {
            Integer top = queue.poll();
            cnt += 1;
            // 遍历当前出队结点的所有后继结点
            for (int[] req : prerequisites) {
                if(req[1] != top) continue;
                inDegree[req[0]]--;
                if (inDegree[req[0]] == 0) {
                    queue.add(req[0]);
                }
            }
        }
        return cnt == numCourses;
    }
}

2.深度优先遍历

（1）借助一个标志列表 flags，用于判断每个节点 i （课程）的状态：
未被 DFS 访问：i = 0；
已被其他节点启动的DFS访问：i = -1；
已被当前节点启动的DFS访问：i = 1。
（2）对 numCourses 个节点依次执行 DFS，判断每个节点起步 DFS 是否存在环，若存在环直接返回 False。
DFS 流程：
a.终止条件：
当 flag[i] = = -1，说明当前访问节点已被其他节点启动的 DFS 访问，无需再重复搜索，直接返回 True。
当 flag[i] = = 1，说明在本轮 DFS 搜索中节点 i 被第 2 次访问，即 课程安排图有环，直接返回 False。
b.将当前访问节点 i 对应 flag[i] 置 1，即标记其被本轮 DFS 访问过；
c.递归访问当前节点 i 的所有邻接节点 j，当发现环直接返回 False；
d.当前节点所有邻接节点已被遍历，并没有发现环，则将当前节点 flag 置为 -1 并返回 True。
（3）若整个图 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;
    }
}