拓扑排序 Java

一、引入

我们知道，某些课程只能在一些其他前置课程学完之后学习，或是说一些任务只能在其他任务结束之后完成。要如何找到做这些事情的顺序呢？

其实很明显，我们只需先完成没有前置要求的任务，或是说将某些任务的前置任务完成之后再开始处理这些任务。

这些事情是有先后顺序的，且不成环。如果存在环，就像你找人处理事情，他让你找另一个人，另一个人又让你去找… 最后又回到刚开始的那个人。结果这些人互相踢皮球，问题无从下手。

处理这类问题，我们可以用 图 来表示，节点表示 课程，有向边表示前置条件。那么问题可以转换为：能否列出一个序列，对 图 的每一条有向边而言，边的起始顶点总是排在边的结束顶点之前。 而这样的序列称之为拓扑序列，这样的问题称之为 拓扑排序。

假设有 5 门课程，编号 1 ~ 5，其中 1 号课程和 2 号课程没有其他课程要求，学习 3 号课程之前需要先学习1 号和 2 号课程，学习 4 号课程需要先学习 3 号课程，学习5 号课程需要先学习 3 号和 4 号课程。

那么我们可以得到拓扑序列：1，2，3，4，5 或 2，1，3，4，5。
可以看出，拓扑序列并不唯一。

二、实现方式

暂时记录一种，后续再展开。

1、减一法

减一法是基于减治思想的一个实现：我们不断做这样一件事情，在余下的有向图中，我们去选择一个没有被指向的顶点（没有前置条件的任务），可以任意选择，选择后我们去除这个顶点以及从该顶点出发的边；而当这样的顶点不存在时（queue为空时），流程就终止，此时比较这样的顶点数量和总顶点数量是否一致，来判断是否可行。

那么最终的解是 1，2，3，4，5
那么我们知道 哪些顶点是被指向，哪些顶点没有被指向呢？
其实很简单，我们需要再说明一些定义：

在有向图中，顶点 v 的
入度：以 v 作为终点的边数。
出度：以 v 作为起点的边数。

因此，我们想要知道一个顶点有没有被指向，其实只需看该顶点的入度是否为 0。
我们如何维护每个顶点的入度呢，其实只需在建图时，将入度记录在入度表int[] indegree即可；而在拓扑排序中选择一个顶点后，将从该顶点出发的有向边指向的那些顶点的入度减一即可。
这样，我们维护一个队列queue记录当前还未处理的入度为 0 的顶点，每次处理一个顶点并记录在 ans，同时将新的入度变为 0 的顶点加入到队列。

例题01

代码例题连接

代码实现01

//原题链接：https://www.nowcoder.com/practice/88f7e156ca7d43a1a535f619cd3f495c

import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {

    // 最大顶点的数量
    public static int N = 200001;

    // 拓扑排序用到的队列， 即记录 入度为 0 的顶点
    public static int[] queue = new int[N];

    public static int l, r; // 队列的开头，结尾

    // 入度表，i 号顶点的入度 即 indegree[i]
    public static int[] indegree = new int[N];

    // 邻接表 建图
    public static List<Integer>[] g;

    // 收集的一条拓扑序列
    public static List<Integer> ans = new ArrayList<>();

    public static int n, m;

    public static void main(String[] args) throws IOException {

        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        String[] str = in.readLine().split(" ");
        n = Integer.parseInt(str[0]);
        m = Integer.parseInt(str[1]);

        // 建图
        g = new ArrayList[n + 1];
        for (int i = 0; i <= n; i++) {
            g[i] = new ArrayList<>();
        }
        Arrays.fill(indegree, 0, n + 1, 0); // 刷新入度，置为 0

        for (int i = 0; i < m; i++) {
            str = in.readLine().split(" ");
            int x = Integer.parseInt(str[0]);
            int y = Integer.parseInt(str[1]);

            // 添加 有向边 x -> y
            g[x].add(y);
            indegree[y]++; // 指向y，y的入度 +1
        }

        // 拓扑排序
        topSort();

        // 若 记录序列 的 顶点个数不为 n，说明不存在 拓扑序
        if (ans.size() != n) {
            out.println(-1);
        } else {
            for (int i = 0; i < n - 1; i++) {
                out.print(ans.get(i) + " ");
            }
            out.println(ans.get(n - 1));
        }

        out.flush();
        out.close();
        in.close();

    }

    public static void topSort() {
        //清空上一次的记录
        l = r = 0; 
        ans.clear();

        // 将入度 为 0 的顶点 入队
        for (int i = 1; i <= n; i++) {
            if (indegree[i] == 0) queue[r++] = i;
        }

        while (l < r) {
            int x = queue[l++];
            ans.add(x);
            for (int y : g[x]) {
                // 移除 x -> y, y 入度变为 0 则入队
                if (--indegree[y] == 0) queue[r++] = y;
            }
        }
    }
}

参考代码：参考代码链接
参考博主： 博主主页链接

参考文献：
[1] Anany Levitin，潘彦(译)。算法设计与分析基础(第3版)