拓扑排序 学习笔记

今天，我们来聊聊拓扑排序。

何为拓扑排序？

拓扑排序，这个顾名思义似乎有点难。那就直接上定义吧：

对于一个DAG(有向无环图)\(G\)，将 \(G\) 中所有顶点排序为一个线性序列，使得图中任意一对顶点 \(u\) 和 \(v\)，若 \(u\) 和 \(v\) 之间存在一条从 \(u\) 指向 \(v\) 的边，那么 \(u\) 在线性序列中一定在 \(v\) 前。

啥意思呢。比如这样一个DAG：

几种可能的拓扑序是：

• 1 2 4 3 5 6 7
• 1 2 3 4 5 6 7
• 1 4 2 5 6 3 7

也就是说，DAG的拓扑序可能并不唯一。

那么，1 3 2 4 5 6 7是不是这张图的拓扑序呢？答案是否定的，因为图中存在 \(2 \rightarrow 3\) 这条边，那么2必须出现在3的前面，但是这里2却出现在3的后面，因此不是拓扑序。

拓扑排序和DAG的关系

现在，你对拓扑排序的理解一定加深了一些。那么接下来让我们思考一个问题，拓扑排序为什么一定要在DAG上？不在DAG上难道不行吗？

首先，DAG是有向无环图的意思，我们从有向和无环两个方面分别做反义词，也就是无向，有环。

接下来我们证明为什么这两种情况不能出现。

为什么有无向边的图无拓扑序？

假设存在有无向边的有 \(n\) 个点的图 \(G\) 的拓扑序 \(a\)，那么一定存在两个数 \(i, j (1 \le i, j \le n)\)，满足 \(a_i \rightarrow a_j \in G, a_j \rightarrow a_i \in G\)。根据拓扑序的定义，就有 \(i < j\) 且 \(i > j\)，显然不存在 \(i, j\) 满足此逻辑关系，即有无向边的图无拓扑序。

为什么有环的图无拓扑序？

假设存在有环的有 \(n\) 个点的图 \(G\) 的拓扑序 \(a\)，那么一定存在 \(k(1 < k \le n), p(1 \le p \le n - k)\) 使得 \(a_{p+1} \rightarrow a_{p+2}, a_{p+2} \rightarrow a_{p+3}, a_{p+3} \rightarrow a_{p+4}, \ldots, a_{p+k-1} \rightarrow a_{p+k}, a_{p+k} \rightarrow a_{p+1} \in G\)。根据拓扑序的定义，就有 \(p + k < p + 1\)，但 \(k > 1\)，因此 \(p + k < p + 1\) 不可被满足，即有环图无拓扑序。

其实，无向边可以看做包含两个点的环，所以他们的证明很相似。

至此证毕。

拓扑排序的实现

dfs

众所周知，dfs可以解决任何一个不带时限的题目(

那么我们就来想下怎么用dfs实现拓扑排序吧。

• 首先定义一个标记数组 \(flag\)。
• 初始化 \(flag_i = 0\)
• 循环遍历 \(u = 1 \rightarrow n\)，当 \(flag_u = 0\) 时，进行dfs。dfs此处是一个bool函数，如果返回true则代表运行正常，如果返回false代表发现了环或无向边。那么如果此时的dfs函数返回一个false值，直接返回，无拓扑序。至于dfs怎么判环，会在下方的dfs函数处理步骤给出。

接下来是dfs函数处理步骤：

• 对于一个来自参数的节点 \(u\)，先令 \(flag_u \leftarrow -1\)，然后遍历其出边。如果发现 \(u \rightarrow v \in G\)，且 \(flag_v = -1\)，说明有环，返回false。然后如果 \(flag_v = 0\)(\(flag_v = 1\) 代表此点安全，不必再处理)，我们就进行dfs(v)的操作。如果递归的dfs(v)返回了false，本体也返回false。
• 如果没有返回false，说明当前节点处理正常。令 \(flag_u \leftarrow 1\)，将 \(u\) 节点插入拓扑序，返回true。

核心代码如下：

int flag[maxn];
std :: vector  topo;
std :: vector  G[maxn];
int n, m;

bool dfs(int u) {
    flag[u] = -1;
    for (int i = 0; i < G[u].size(); ++i) {
        int v = G[u][i];
        if (flag[v] == -1) return false;
        else if (flag[v] == 0) {
            if (!dfs(v)) return false;
        }
    }
    flag[u] = 1;
    topo.push_back(u);
    return true;
}

bool toposort() {
    topo.clear();
    for (int i = 1; i <= n; ++i) flag[i] = 0;
    for (int i = 1; i <= n; ++i) {
        if (flag[i] == 0) {
            if (!dfs(i)) return false;
        }
    }
    std :: reverse(topo.begin(), topo.end());
    return true;
}

Kahn算法

Kahn算法有时候也叫做toposort的bfs版本。

算法流程如下:

• 将入度为 \(0\) 的点组成一个集合 \(S\)
• 从 \(S\) 中取出一个顶点 \(u\)，插入拓扑序列。
• 遍历顶点 \(u\) 的所有出边，并全部删除，如果删除这条边后对方的点入度为 \(0\)，也就是没删前，\(u \rightarrow v\) 这条边已经是 \(v\) 的最后一条入边，那么就把 \(v\) 插入 \(S\)。
• 重复执行上两个操作，直到 \(S = \varnothing\)。此时检查拓扑序列是否正好有 \(n\) 个节点，不多不少。如果拓扑序列中的节点数比 \(n\) 少，说明 \(G\) 非DAG，无拓扑序，返回false。如果拓扑序列中恰好有 \(n\) 个节点，说明 \(G\) 是DAG，返回拓扑序列。

也就是说，Kahn算法的核心就是维护一个入度为0的顶点。

核心代码如下：

int ind[maxn];
bool toposort() {
    topo.clear();
    std :: queue  q;
    for (int i = 1; i <= n; ++i) {
        if (ind[i] == 0) q.push(i);
    }

    while (!q.empty()) {
        int u = q.front();
        topo.push_back(u);
        q.pop();
        for (int i = 0; i < G[u].size(); ++i) {
            int v = G[u][i];
            --ind[v];
            if (ind[v] == 0) q.push(v);
        }
    }

    if (topo.size() == n) return true;
    return false;
}

拓扑排序实现的时间复杂度

Kahn算法和dfs算法的时间复杂度都为 \(\operatorname{O}(E+V)\)。感兴趣的读者可以自证，这里不再详细阐述。

另外，如果要求字典序最小或最大的拓扑序，只需要将Kahn算法中的q队列替换为优先队列即可，总时间复杂度为 \(\operatorname{O}(E+V\log V)\)。

拓扑排序的用途

说了这么半天，拓扑排序有什么用途吗？

• 判环
• 判链
• 处理依赖性任务规划问题

处理依赖性任务规划问题的模板是UVA10305，可以做做看。

本篇文章至此结束。