拓扑图算法题-Acwing848. 有向图的拓扑序列

前置知识

在图论中,拓扑排序是对有向无环图(DAG,Directed Acyclic Graph)进行的一种排序。在拓扑排序中,有两个重要的概念,即“入度”和“出度”。

  1. 入度(In-Degree):

    • 对于有向图中的每个顶点,入度表示指向该顶点的边的数量。
    • 具体说,如果存在一条边从顶点 A 指向顶点 B,那么顶点 B 的入度就加 1。
    • 入度反映了图中某个节点作为终点的频率,即有多少条边指向该节点。
  2. 出度(Out-Degree):

    • 对于有向图中的每个顶点,出度表示从该顶点出发的边的数量。
    • 具体说,如果存在一条边从顶点 A 出发指向顶点 B,那么顶点 A 的出度就加 1。
    • 出度反映了图中某个节点作为起点的频率,即有多少条边从该节点出发。

在拓扑排序中,一般首先选取入度为 0 的节点作为起始节点,然后不断删除起始节点并更新其相邻节点的入度,直至所有节点被遍历。这样得到的顺序即为拓扑排序。

关于拓扑排序的算法步骤:

  1. 统计每个节点的入度。
  2. 将入度为 0 的节点加入队列。
  3. 遍历队列,每次取出一个节点,更新其相邻节点的入度。
  4. 将入度为 0 的相邻节点加入队列。
  5. 重复步骤 3-4,直到队列为空。

拓扑排序常用于表示任务的依赖关系,例如工程项目的任务安排,编译过程中源文件的编译顺序等。

题目

给定一个 n个点 m 条边的有向图,点的编号是 1 到 n,图中可能存在重边和自环。

请输出任意一个该有向图的拓扑序列,如果拓扑序列不存在,则输出 −1−1。

若一个由图中所有点构成的序列 A 满足:对于图中的每条边 (x,y),x在 A中都出现在 y之前,则称 A是该图的一个拓扑序列。

输入格式

第一行包含两个整数 n和 m。

接下来 m 行,每行包含两个整数 x 和 y,表示存在一条从点 x到点 y 的有向边 (x,y)。

输出格式

共一行,如果存在拓扑序列,则输出任意一个合法的拓扑序列即可。

否则输出 −1。

数据范围

1≤n,m≤105

输入样例:
3 3
1 2
2 3
1 3
输出样例:
1 2 3

代码与解析

  1. 构建有向图:通过输入的边信息构建有向图,同时统计每个节点的入度。
  2. 拓扑排序:将所有入度为 0 的节点加入队列,然后依次取出队列中的节点,更新其邻接节点的入度,并将新的入度为 0 的节点加入队列。循环直到队列为空。
  3. 判断是否有环:如果拓扑排序得到的节点数等于总节点数,说明图中无环,可以进行拓扑排序;否则,说明图中存在环,无法进行拓扑排序。
import java.util.*;

public class TopologicalSort {
    static int n, m, idx, N = 100010, record;
    static int[] e = new int[N], ne = new int[N], h = new int[N], dis = new int[N];
    static Queue<Integer> q = new LinkedList<>();
    static List<Integer> list = new ArrayList<>();

    // 添加有向边
    public static void add(int a, int b) {
        e[idx] = b;
        ne[idx] = h[a];
        h[a] = idx++;
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        n = in.nextInt();  // 节点数
        m = in.nextInt();  // 边数

        Arrays.fill(h, -1);  // 初始化邻接表头数组为 -1

        // 构建有向图并计算每个节点的入度
        for (int i = 0; i < m; i++) {
            int a = in.nextInt();
            int b = in.nextInt();
            add(a, b);
            dis[b]++;
        }

        if (topSort()) {
            // 输出拓扑排序结果
            for (int i = 0; i < list.size(); i++) {
                System.out.print(list.get(i) + " ");
            }
        } else {
            // 说明图中存在环,无法进行拓扑排序
            System.out.println(-1);
        }
    }

    // 拓扑排序
    private static boolean topSort() {
        for (int i = 1; i <= n; i++) {
            // 将入度为 0 的节点加入队列
            if (dis[i] == 0) {
                q.offer(i);
            }
        }

        while (!q.isEmpty()) {
            record++;
            int t = q.poll();
            list.add(t);

            // 遍历以 t 为起点的所有边
            for (int i = h[t]; i != -1; i = ne[i]) {
                int j = e[i];
                dis[j]--;

                // 如果节点 j 的入度为 0,则加入队列
                if (dis[j] == 0) {
                    q.offer(j);
                }
            }
        }

        // 如果拓扑排序得到的节点数等于总节点数,说明无环,返回 true
        return record == n;
    }
}

你可能感兴趣的:(#,Acwing,算法,拓扑学,java)