拓扑排序

拓扑排序(Kahn 算法)

一、什么是拓扑排序

拓扑排序(Topological Sort)是对有向无环图(DAG)的所有节点进行线性排序,使得对于每一条有向边 u -> v,节点 u 都排在节点 v 的前面。

通俗理解:把一堆有先后依赖关系的任务排成一个顺序,保证每个任务执行时,它依赖的所有任务都已经执行完。

典型场景

  • 课程安排:先修课关系
  • 编译顺序:源文件之间的依赖
  • 任务调度:任务之间的前置依赖
  • 检测有向图是否有环

二、前提:有向无环图(DAG)

拓扑排序只适用于有向无环图。

  • 如果图中有环,则不存在拓扑排序
  • 反过来,如果一个图能完成拓扑排序,说明它无环

所以拓扑排序也常用来判断有向图是否有环。

三、核心概念:入度

入度:指向某个节点的边的数量。

例如有边 A -> B、C -> B,那么 B 的入度是 2。

拓扑排序的关键观察:

入度为 0 的节点,没有任何前置依赖,可以立刻执行。

四、Kahn 算法流程

Kahn 算法是拓扑排序最常用的实现方式,本质是一个 BFS:

  1. 统计所有节点的入度 inDegree[]
  2. 把所有入度为 0 的节点加入队列
  3. 不断从队列取出节点 u:
    • 把 u 加入拓扑序列
    • 遍历 u 的所有出边 u -> v,把 v 的入度减 1
    • 如果 v 的入度变成 0,把 v 加入队列
  4. 重复直到队列为空
  5. 如果拓扑序列中的节点数等于总节点数,说明无环;否则有环

五、Kahn 算法的经典应用

1 判断有向图是否有环

拓扑排序完成后,如果节点数不足 n,说明存在环。

2 求字典序最小的拓扑序

把队列换成优先队列(小根堆):

priority_queue<int, vector<int>, greater<int>> q;

这样每次取出的都是当前可用的最小编号节点。

3 求最长路 / 关键路径

在拓扑序上做 DP,可以求 DAG 上的最长路径(最短路径)。

4 依赖关系调度

六、模板代码

6.1 邻接表版

#include<bits/stdc++.h>
using namespace std;

const int N = 1e5 + 5;

vector<int> adj[N];
int inDegree[N];
int n, m;

vector<int> topoSort() {
    vector<int> result;
    queue<int> q;

    // 把所有入度为 0 的节点入队
    for (int i = 1; i <= n; i++) {
        if (inDegree[i] == 0) q.push(i);
    }

    while (!q.empty()) {
        int u = q.front();
        q.pop();
        result.push_back(u);

        // 遍历 u 的所有出边
        for (int v : adj[u]) {
            inDegree[v]--;
            if (inDegree[v] == 0) q.push(v);
        }
    }

    // 如果结果数量不足 n,说明有环
    if ((int)result.size() != n) return {};
    return result;
}

int main() {
    cin >> n >> m;
    for (int i = 0; i < m; i++) {
        int u, v;
        cin >> u >> v;
        adj[u].push_back(v);
        inDegree[v]++;
    }

    vector<int> ans = topoSort();
    if (ans.empty()) {
        cout << "有环,不存在拓扑排序\n";
    } else {
        for (int x : ans) cout << x << " ";
        cout << "\n";
    }
    return 0;
}

6.2 链式前向星版

#include<bits/stdc++.h>
using namespace std;

const int N = 1e5 + 5;
const int M = 2e5 + 5;

int head[N], to[M], nxt[M];
int cnt = 1;
int inDegree[N];
int n, m;

void add(int u, int v) {
    to[cnt] = v;
    nxt[cnt] = head[u];
    head[u] = cnt;
    cnt++;
}

vector<int> topoSort() {
    vector<int> result;
    queue<int> q;

    for (int i = 1; i <= n; i++) {
        if (inDegree[i] == 0) q.push(i);
    }

    while (!q.empty()) {
        int u = q.front();
        q.pop();
        result.push_back(u);

        for (int i = head[u]; i != -1; i = nxt[i]) {
            int v = to[i];
            inDegree[v]--;
            if (inDegree[v] == 0) q.push(v);
        }
    }

    if ((int)result.size() != n) return {};
    return result;
}

int main() {
    cin >> n >> m;
    memset(head, -1, sizeof(head));

    for (int i = 0; i < m; i++) {
        int u, v;
        cin >> u >> v;
        add(u, v);
        inDegree[v]++;
    }

    vector<int> ans = topoSort();
    if (ans.empty()) {
        cout << "有环,不存在拓扑排序\n";
    } else {
        for (int x : ans) cout << x << " ";
        cout << "\n";
    }
    return 0;
}

七、复杂度

操作 时间复杂度
统计入度 O(m)
拓扑排序 O(n + m)
总复杂度 O(n + m)

每个节点和每条边都只会被处理一次,非常高效。

九、注意:拓扑排序只适用于 DAG,有环的图无解

十、总结

要点 内容
适用图 有向无环图(DAG)
核心操作 入度为 0 入队,出边入度减 1
判断有环 拓扑序节点数不足 n
复杂度 O(n + m)
变体 字典序最小(优先队列)、最长路(拓扑 DP)
posted @ 2026-10-03 17:09  leaderling  阅读(37)  评论(0)    收藏  举报