leetcode拓扑排序算法总结

在图论中，拓扑排序(Topological Sorting)是一个有向无环图(DAG, Directed Acyclic Graph)的所有顶点的线性序列。所以可以通过有向图是否存在拓扑排序来确定该有向图是否有环。计算有向图拓扑排序的常见算法如下：

• 从 DAG 图中选择一个 没有前驱（即入度为0）的顶点并输出。
• 从图中删除该顶点和所有以它为起点的有向边。
• 重复 1 和 2 直到当前的 DAG 图为空或当前图中不存在无前驱的顶点为止。后一种情况说明有向图中必然存在环。

207.课程表

现在你总共有 n 门课需要选，记为 0 到 n-1。

在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们: [0,1]

给定课程总量以及它们的先决条件，判断是否可能完成所有课程的学习？

输入: 2, [[1,0]] 
输出: true
解释: 总共有 2 门课程。学习课程 1 之前，你需要完成课程 0。所以这是可能的。

输入: 2, [[1,0],[0,1]]
输出: false
解释: 总共有 2 门课程。学习课程 1 之前，你需要先完成​课程 0；并且学习课程 0 之前，你还应先完成课程 1。这是不可能的。

本题只需要输出是否可完成，因此也可用dfs直接判断图中是否有环即可。在这里给出拓扑排序的解法。由于题中给出的是边列表，先把它转化成图的邻接表形式。每次都要找出图中度为0的节点，一开始只保存了图，导致每次都要计算更新节点的入度，导致算法超时。多维护一个入度表即可解决，只需要在删除边时将相应入度减1即可。用队列存储入度为0的节点，同时维护一个计数器，当入队数为课程总数时返回true，即所有课程都可完成，提前返回，后面无需继续计算了。

class Solution {
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        int[] degree = new int[numCourses];  //入度表
        ArrayList<ArrayList<Integer>> graph = new ArrayList<ArrayList<Integer>>();
        Queue<Integer> queue = new LinkedList<>();
        int cnt = 0; //计数
        for(int i=0;i<numCourses;i++) {
            graph.add(new ArrayList<>());
        } 
        //构建邻接表和入度表
        for(int i=0;i<prerequisites.length;i++) {
            degree[prerequisites[i][0]] += 1;
            graph.get(prerequisites[i][1]).add(prerequisites[i][0]);
        }  
        for(int i=0;i<numCourses;i++) {
            if(degree[i] == 0) {
                queue.offer(i);
                cnt++;
                if(cnt == numCourses) {
                        return true;
                    }
            }
        }
        while(!queue.isEmpty()) {
            int course = queue.poll();
            for(Integer index:graph.get(course)) {
                degree[index]--;
                if(degree[index] == 0) {
                    queue.offer(index);
                    cnt++;
                    if(cnt == numCourses) {
                        return true;
                    }
                }
            }
        }
        return false;
    }
}

210.课程表2

现在你总共有 n 门课需要选，记为 0 到 n-1。

在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们: [0,1]

给定课程总量以及它们的先决条件，返回你为了学完所有课程所安排的学习顺序。

可能会有多个正确的顺序，你只要返回一种就可以了。如果不可能完成所有课程，返回一个空数组。

输入: 2, [[1,0]] 
输出: [0,1]
解释: 总共有 2 门课程。要学习课程 1，你需要先完成课程 0。因此，正确的课程顺序为 [0,1] 。

输入: 4, [[1,0],[2,0],[3,1],[3,2]]
输出: [0,1,2,3] or [0,2,1,3]
解释: 总共有 4 门课程。要学习课程 3，你应该先完成课程 1 和课程 2。并且课程 1 和课程 2 都应该排在课程 0 之后。
     因此，一个正确的课程顺序是 [0,1,2,3] 。另一个正确的排序是 [0,2,1,3] 。

本题需要输出任意一种拓扑排序，将上题的代码稍作修改，输出拓扑排序结果即可。

class Solution {
    public int[] findOrder(int numCourses, int[][] prerequisites) {
        int[] degree = new int[numCourses];  //入度表
        ArrayList<ArrayList<Integer>> graph = new ArrayList<ArrayList<Integer>>();
        Queue<Integer> queue = new LinkedList<>();
        int[] ret = new int[numCourses];
        int cnt=0;
        for(int i=0;i<numCourses;i++) {
            graph.add(new ArrayList<>());
        } 
        //构建邻接表和入度表
        for(int i=0;i<prerequisites.length;i++) {
            degree[prerequisites[i][0]] += 1;
            graph.get(prerequisites[i][1]).add(prerequisites[i][0]);
        }  
        for(int i=0;i<numCourses;i++) {
            if(degree[i] == 0) {
                queue.offer(i);
                ret[cnt++] = i;
                if(cnt == numCourses) {
                    return ret;
                }
            }
        }
        while(!queue.isEmpty()) {
            int course = queue.poll();
            for(Integer index:graph.get(course)) {
                degree[index]--;
                if(degree[index] == 0) {
                    queue.offer(index);
                    ret[cnt++] = index;
                    if(cnt == numCourses) {
                        return ret;
                    }
                }
            }
        }
        return new int[0];
    }
}