拓扑排序 Topological Sort

最新推荐文章于 2021-09-13 23:20:32 发布

aitie1479

最新推荐文章于 2021-09-13 23:20:32 发布

阅读量147

点赞数

文章标签：数据结构与算法

原文链接：http://www.cnblogs.com/hyserendipity/p/8980954.html

版权

2018-05-02 16:26:07

在计算机科学领域，有向图的拓扑排序或拓扑排序是其顶点的线性排序，使得对于从顶点u到顶点v的每个有向边uv，u在排序中都在v前。例如，图形的顶点可以表示要执行的任务，并且边缘可以表示一个任务必须在另一个任务之前执行的约束; 在这个应用中，拓扑排序只是一个有效的任务顺序。如果且仅当图形没有定向循环，即如果它是有向无环图（DAG），则拓扑排序是可能的。任何 DAG 具有至少一个拓扑排序，并且已知这些算法用于在线性时间内构建任何 DAG 的拓扑排序。 $u$

对于一个DAG，其拓扑排序不一定是唯一的，下图中合法的拓扑排序有很多，如：

5, 7, 3, 11, 8, 2, 9, 10 (visual left-to-right, top-to-bottom)
3, 5, 7, 8, 11, 2, 9, 10 (smallest-numbered available vertex first)
5, 7, 3, 8, 11, 10, 9, 2 (fewest edges first)
7, 5, 11, 3, 10, 8, 9, 2 (largest-numbered available vertex first)
5, 7, 11, 2, 3, 8, 9, 10 (attempting top-to-bottom, left-to-right)
3, 7, 8, 5, 11, 10, 2, 9 (arbitrary)

一、拓扑排序算法

通常拓扑排序算法可以在O(n)的时间复杂度完成，具体来说是O(V + E)。下面以leetcode207为例来介绍拓扑排序算法。

问题描述：

问题求解：

方法一、DFS

    public boolean canFinish(int numCourses, int[][] prerequisites) {
        List<Integer>[] graph = new List[numCourses];
        for (int i = 0; i < numCourses; i++) graph[i] = new ArrayList<>();
        for (int[] pair : prerequisites) {
            graph[pair[1]].add(pair[0]);
        }
        int[] state = new int[numCourses];
        for (int i = 0; i < numCourses; i++) {
            if (state[i] == 0) {
                if (!dfs(graph, state, i))
                    return false;
            }
        }
        return true;
    }

    private boolean dfs(List<Integer>[] g, int[] state, int i) {
        if (state[i] == 2) return true;
        if (state[i] == 1) return false;
        state[i] = 1;
        for (int node : g[i]) {
            if (!dfs(g, state, node)) return false;
        }
        state[i] = 2;
        return true;
    }

方法二、Kahn's algorithm

所谓Kahn算法，就是以入度为衡量因子的算法，即每次将入度为0的点“删除”，同时将其邻接边的顶点入度减一，重复上述过程即可。

    public boolean canFinish(int numCourses, int[][] prerequisites) {
        List<Integer>[] graph = new List[numCourses];
        int[] indegree = new int[numCourses];
        for (int i = 0; i < numCourses; i++) graph[i] = new ArrayList<>();
        for (int[] pair : prerequisites) {
            indegree[pair[0]]++;
            graph[pair[1]].add(pair[0]);
        }

        Queue<Integer> q = new LinkedList<>();
        for (int i = 0; i < numCourses; i++)
            if (indegree[i] == 0)
                q.add(i);
        int cnt = 0;
        while (!q.isEmpty()) {
            int cur = q.poll();
            cnt++;
            for (int node : graph[cur]) {
                if (--indegree[node] == 0) q.add(node);
            }
        }
        return cnt == numCourses;
    }

二、拓扑排序应用

210. Course Schedule II

问题描述：

问题求解：

也是一条裸的拓扑排序题，相较于上一题，本题可以说是更纯粹的拓扑排序，因为不仅需要判环，还需要输出一个合法的解。当然，算法实现上也是两种思路，一是DFS，而是kahn算法。

DFS：

    public int[] findOrder(int numCourses, int[][] prerequisites) {
        int[] res = new int[numCourses];
        List<Integer>[] graph = new List[numCourses];
        for (int i = 0; i < numCourses; i++) graph[i] = new ArrayList<>();
        for (int[] pair : prerequisites) {
            graph[pair[1]].add(pair[0]);
        }
        int[] state = new int[numCourses];
        Stack<Integer> s = new Stack<>();
        for (int i = 0; i < numCourses; i++) {
            if (state[i] == 0)
                if (!dfs(graph, state, s, i)) return new int[0];
        }
        for (int i = 0; i < numCourses; i++) res[i] = s.pop();
        return res;
    }

    private boolean dfs(List<Integer>[] g, int[] state, Stack<Integer> s, int i) {
        if (state[i] == 2) return true;
        if (state[i] == 1) return false;
        state[i] = 1;
        for (int node : g[i]) {
            if (!dfs(g, state, s, node)) return false;
        }
        state[i] = 2;
        s.push(i);
        return true;
    }

Kahn：

    public int[] findOrder(int numCourses, int[][] prerequisites) {
        int[] res = new int[numCourses];
        int[] indegree = new int[numCourses];
        List<Integer>[] graph = new List[numCourses];
        for (int i = 0; i < numCourses; i++) graph[i] = new ArrayList<>();
        for (int[] pair : prerequisites) {
            graph[pair[1]].add(pair[0]);
            indegree[pair[0]]++;
        }
        Queue<Integer> q = new LinkedList<>();
        for (int i = 0; i < numCourses; i++) {
            if (indegree[i] == 0)
                q.add(i);
        }
        int cnt = 0;
        while (!q.isEmpty()) {
            int p = q.poll();
            res[cnt++] = p;
            for (int node : graph[p]) {
                if (--indegree[node] == 0) q.add(node);
            }
        }
        if (cnt == numCourses) return res;
        else return new int[0];
    }

转载于:https://www.cnblogs.com/hyserendipity/p/8980954.html