拓扑排序详解（梅开二度之dfs版按字典序输出拓扑路径+dfs版输出全部拓扑路径

什么是拓扑排序？

先穿袜子再穿鞋，先当孙子再当爷。这就是拓扑排序！

拓扑排序说白了其实不太算是一种排序算法，但又像是一种排序（我是不是说了个废话qwq）

他其实是一个有向无环图（DAG, Directed Acyclic Graph的所有顶点的线性序列，该序列需要满足两个条件：

• 每个节点只能出现一次
• 若存在一条A到B到路径，则在拓扑序列中A必然出现在B前面

而有向无环图才具有拓扑排序，非DAG图则没有拓扑排序一说

先看一道拓扑排序的水题趴(>_<)

UVa 10305 - Ordering Tasks

题意：

有n个任务要做，有m个要求，每个要求有两个数x，y，要求x必须在y之前执行，让你输出一种执行任务的序列

这里窝给出两种方法，一种dfs，一种bfs，两种建图方法，一种邻接链表，一种链式前向星

再看一道稍微有点变化的拓扑排序

1089.拓扑排序

题意：

给定一个有向图，若存在环，输出IMPOSABLE，否则输出一行用一个空格隔开的拓扑排序的结果，若存在多个结果，输出字典序最小的。

既需要判断是否有环也需要输出字典序最小的

同样的，窝给出两种方法，一种dfs，一种bfs，来判环以及输出字典序最小

bfs版拓扑排序

问题1:

主要思想就是找出所有入度为0的点，给他们扔进队列里面，然后对对列的元素进行如下操作：取队首赋为now，扔队首，遍历now的所有后继节点，并让他们的入度减1，同时进行判断入度是否减到了0，如果到0了，就扔进对列，一直循环到对列为空结束

如果需要按字典序输出，就用优先队列

邻接链表建图：

使用vector，注意要每次初始化vector

#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <stdlib.h>
#include <sstream>
#include <map>
#include <set>
using  namespace std;
#define inf 0x3f3f3f3f
#define MAX 200000 + 50
#define endl '
'
#define seed 13331
#define mod 1000000000 + 7
#define io ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define mem(a,b) memset((a),(b),sizeof(a))
typedef  long long ll ;
//不开longlong见祖宗！
//inline __int128 read(){__int128 x = 0, f = 1;char ch = getchar();while(ch < '0' || ch > '9'){if(ch == '-'){f = -1;}ch = getchar();}while(ch >= '0' && ch <= '9'){x = x * 10 + ch - '0';ch = getchar();}return x * f;}
//inline void print(__int128 x){if(x < 0){putchar('-');x = -x;}if(x > 9){print(x / 10);}putchar(x % 10 + '0');}
inline int IntRead(){char ch = getchar();int s = 0, w = 1;while(ch < '0' || ch > '9'){if(ch == '-') w = -1;ch = getchar();}while(ch >= '0' && ch <= '9'){s = s * 10 + ch - '0';ch = getchar();}return s * w;}
inline void write(int x){if (x < 0) {x = ~x + 1; putchar('-');}if (x > 9){write(x / 10);}putchar(x % 10 + '0');}

int n, m, a, b, now;
vector<vector<int> >tr;
int in[MAX];
queue<int>q;
bool vis[MAX];

void topsort(){
    for(int i = 1; i <= n; ++i){
        if(in[i] == 0)q.push(i);//找到所有入度为0的点，入队
    }
    while (!q.empty()) {
        now = q.front();q.pop();//取队首，记得pop
        if(vis[now])continue;//如果访问过就跳过
        vis[now] = 1;//没访问就标记一下
        cout<<now<<' ';//输出
        for(int i = 0; i < tr[now].size(); ++i){
            int v = tr[now][i];
            --in[v];//入度减一
            if(in[v] == 0)q.push(v);//如果入度为0，入队
        }
    }
    cout<<endl;
}

int main(){
    io;
    while (cin>>n>>m && (n + m)) {
        mem(in, 0);
        mem(vis, 0);
        tr = vector<vector<int> >(n + 1);//初始化
        for(int i = 1; i <= m; ++i){
            cin>>a>>b;
            tr[a].push_back(b);//b为a的后继节点，就无脑塞
            ++in[b];//b的入度加一
        }
        topsort();
    }
    return 0;
}

链式前向星建图：

主要的思想没有变化，只不过用的是链式前向星建图，相当于板子而已，写多了就习惯了，再加上如果怕vector被卡的话就采用链式前向星

#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <stdlib.h>
#include <sstream>
#include <map>
#include <set>
using  namespace std;
#define inf 0x3f3f3f3f
#define MAX 200000 + 50
#define endl '
'
#define seed 13331
#define mod 1000000000 + 7
#define io ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define mem(a,b) memset((a),(b),sizeof(a))
typedef  long long ll ;
//不开longlong见祖宗！
//inline __int128 read(){__int128 x = 0, f = 1;char ch = getchar();while(ch < '0' || ch > '9'){if(ch == '-'){f = -1;}ch = getchar();}while(ch >= '0' && ch <= '9'){x = x * 10 + ch - '0';ch = getchar();}return x * f;}
//inline void print(__int128 x){if(x < 0){putchar('-');x = -x;}if(x > 9){print(x / 10);}putchar(x % 10 + '0');}
inline int IntRead(){char ch = getchar();int s = 0, w = 1;while(ch < '0' || ch > '9'){if(ch == '-') w = -1;ch = getchar();}while(ch >= '0' && ch <= '9'){s = s * 10 + ch - '0';ch = getchar();}return s * w;}
inline void write(int x){if (x < 0) {x = ~x + 1; putchar('-');}if (x > 9){write(x / 10);}putchar(x % 10 + '0');}

int n, m, a, b, tot, now;
int head[MAX];
int in[MAX];
bool vis[MAX];
struct ran{
    int to, next;
}tr[MAX];
queue<int>q;

void init(){//初始化
    mem(in, 0);
    mem(vis, 0);
    mem(tr, 0);
    mem(head, -1);
    tot = 0;
}

void built(int u, int v){//建图
    tr[++tot].to = v;
    tr[tot].next = head[u];
    head[u] = tot;
}

void topsort(){
    for(int i = 1; i <= n; ++i){
        if(in[i] == 0)q.push(i);
    }
    while (!q.empty()) {
        now = q.front();q.pop();
        if(vis[now])continue;
        vis[now] = 1;
        cout<<now<<' ';
        for(int i = head[now]; i != -1; i = tr[i].next){
            int v = tr[i].to;
            --in[v];
            if(in[v] == 0)q.push(v);
        }
    }
    cout<<endl;
}

int main(){
    io;
    while (cin>>n>>m && (n + m)) {
        init();
        for(int i = 1; i <= m; ++i){
            cin>>a>>b;
            built(a, b);
            ++in[b];
        }
        topsort();
    }
    return 0;
}

问题2:

如何判环呢？

我们只需要记录输出的数字的个数是否等于n即可

如何输出字典序最小呢？

只需要将queue换成priority_queue即可

#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <stdlib.h>
#include <sstream>
#include <map>
#include <set>
using  namespace std;
#define inf 0x3f3f3f3f
#define MAX 200000 + 50
#define endl '
'
#define seed 13331
#define mod 1000000000 + 7
#define io ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define mem(a,b) memset((a),(b),sizeof(a))
typedef  long long ll ;
//不开longlong见祖宗！
//inline __int128 read(){__int128 x = 0, f = 1;char ch = getchar();while(ch < '0' || ch > '9'){if(ch == '-'){f = -1;}ch = getchar();}while(ch >= '0' && ch <= '9'){x = x * 10 + ch - '0';ch = getchar();}return x * f;}
//inline void print(__int128 x){if(x < 0){putchar('-');x = -x;}if(x > 9){print(x / 10);}putchar(x % 10 + '0');}
inline int IntRead(){char ch = getchar();int s = 0, w = 1;while(ch < '0' || ch > '9'){if(ch == '-') w = -1;ch = getchar();}while(ch >= '0' && ch <= '9'){s = s * 10 + ch - '0';ch = getchar();}return s * w;}
inline void write(int x){if (x < 0) {x = ~x + 1; putchar('-');}if (x > 9){write(x / 10);}putchar(x % 10 + '0');}

int n, m, tot, x, y, now;
struct ran{
    int to, next;
}tr[MAX];
int in[1005];
int head[MAX];
bool vis[MAX];
int ans[1005];
int num;
priority_queue<int, vector<int>, greater<int> >q;//优先队列

void built(int u, int v){
    tr[++tot].to = v;
    tr[tot].next = head[u];
    head[u] = tot;
}

void topu(){
    tot = 0;
    while (!q.empty()) {
        now = q.top();q.pop();
        if(vis[now])continue;
        ++tot;//记录数量
        vis[now] = 1;
        ans[++num] = now;
        for(int i = head[now]; i != -1; i = tr[i].next){
//            cout<<tr[i].to;
            --in[tr[i].to];
            if(in[tr[i].to] == 0)q.push(tr[i].to);
        }
    }
}


int main(){
    io;
    n = IntRead();
    m = IntRead();
    mem(head, -1);
    mem(tr, -1);
    for(int i = 1; i <= m; ++i){
        x = IntRead();
        y = IntRead();
        built(x, y);
        ++in[y];
    }
    for(int i = 1; i <= n; ++i){
        if(in[i] == 0){
            q.push(i);
        }
    }
    topu();
    if(tot == n){//如果输出的数的数量等与n，就说明没有环
        for(int i = 1; i <= n; ++i){
            i == 1 ? cout<<ans[i] : cout<<' '<<ans[i];
        }
        cout<<endl;
    }
    else cout<<"IMPOSABLE
";
    return 0;
}

---

dfs版拓扑排序

问题1:

之前写拓扑排序都是用的bfs的方法，没寻思dfs还可以写，直到我做了一下oj的1089，判环的时候发现可以用dfs判环，然后我就好奇如何用dfs进行拓扑排序、如何按字典序输出拓扑序列、如何将所有的拓扑序列都输出，发现网上很少有教这些的，就寻思自己写一写，于是就有了这篇博客o(≧v≦)o

刚开始觉得用dfs写拓扑排序很复杂，这他么的dfs能怎么排？

要从入度为0出发么？

如果有多个入度为0的点，每个都dfs一遍么，那他们会不会乱套？

后来学会了以后感觉简直不可思议，真的是奈何自己没文化，一句wc行天下

---

首先我们讨论一下拓扑排序的性质，对于一个图，他可能会有好多种拓扑排序，但他们满足一个规律：那就是如果存在有向边u->v , 那么结点 u必须排在v之前（前驱）。同时这种性质具有传递性，也就是说如果同时存在v->t, 那么满足u在t之前。同样的，如果u和v两个结点在图中并不满足这种性质，那么谁在前谁在后就无所谓了。正是利用这个规则，我们进行dfs的顺序是无所谓的。

为何？因为我们从root结点开始dfs一遍，可以找到所有的必须在这个root结点之后的点，那么我们就满足了拓扑序的规则了，那么我们无论先dfs(u)还是先dfs(v), 都不会违背这个规则（除非有环），那么同时我们只要按照某种合理的方式存储所有这些点，那么他们就是拓扑序了。

什么是合理的方式？栈！考量一个dfs(u), 在它结束该退出时，它代表它的结点u。在dfs递归中，什么点会最先exit？没有后继结点的点（或者后继已入栈的点）！那么把所有点分成两个集合，一个是待处理的点集D，一个是已拓扑排序后的点集A，当且仅当D中某个点没有后继结点（或该后继结点已经加入了点集A中）时，它可以从D转移到A，而dfs的回溯方式，恰恰就自动实现了这样的功能。 结合代码更容易体会。

---

不需要判环，输出一种拓扑排序（链式前向星法

#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <stdlib.h>
#include <sstream>
#include <map>
#include <set>
using  namespace std;
#define inf 0x3f3f3f3f
#define MAX 200000 + 50
#define endl '
'
#define seed 13331
#define mod 1000000000 + 7
#define io ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define mem(a,b) memset((a),(b),sizeof(a))
typedef  long long ll ;
//不开longlong见祖宗！
//inline __int128 read(){__int128 x = 0, f = 1;char ch = getchar();while(ch < '0' || ch > '9'){if(ch == '-'){f = -1;}ch = getchar();}while(ch >= '0' && ch <= '9'){x = x * 10 + ch - '0';ch = getchar();}return x * f;}
//inline void print(__int128 x){if(x < 0){putchar('-');x = -x;}if(x > 9){print(x / 10);}putchar(x % 10 + '0');}
inline int IntRead(){char ch = getchar();int s = 0, w = 1;while(ch < '0' || ch > '9'){if(ch == '-') w = -1;ch = getchar();}while(ch >= '0' && ch <= '9'){s = s * 10 + ch - '0';ch = getchar();}return s * w;}
inline void write(int x){if (x < 0) {x = ~x + 1; putchar('-');}if (x > 9){write(x / 10);}putchar(x % 10 + '0');}

int n, m, a, b, tot, now;
int head[MAX];
int in[MAX];
bool vis[MAX];
struct ran{
    int to, next;
}tr[MAX];
stack<int>s;

void init(){
    mem(in, 0);
    mem(vis, 0);
    mem(tr, 0);
    mem(head, -1);
    tot = 0;
}

void built(int u, int v){
    tr[++tot].to = v;
    tr[tot].next = head[u];
    head[u] = tot;
}

void dfs(int u){
    vis[u] = 1;//标记一下这个点来过
    for(int i = head[u]; i != -1; i = tr[i].next){
        int v = tr[i].to;
        if(!vis[v])dfs(v);//下一个点如果没来过，就dfs下一个点
    }
    s.push(u);//搜完了就入栈
}

int main(){
    io;
    while (cin>>n>>m && (n + m)) {
        init();
        for(int i = 1; i <= m; ++i){
            cin>>a>>b;
            built(a, b);
            ++in[b];
        }
        for(int i = 1; i <= n; ++i){
            if(!vis[i])dfs(i);
        }
        while (!s.empty()) {
            cout<<s.top()<<' ';s.pop();
        }
        cout<<endl;
    }
    return 0;
}

---

问题2:

如何判环？

判环只是在dfs的基础上稍作修改，其最主要的是对vis数组的含义有所扩展，以及对下一个节点进行dfs判断

不判环对vis只代表该点也没有被访问，而现在vis有三个值，-1，0，1. -1代表已经访问过，但不是当前dfs访问的， 1表示访问过，且是当前的dfs访问的，意味着有环（u->v,v->t,t->u），0表示没访问过

dfs返回的是以root为根节点的后续有没有环，所以我们需要对每个点都去跑一遍dfs，当然，如果已经访问过了，就没必要去dfs他了

伪代码

//判断是否有环(true 没有; false 有)
bool dfs(u) {
	本趟节点标记;
	for(遍历以u为入弧的定点){
			if(是本趟节点）return false;
			else if(如果没访问过) {
				if(子节点有环)return false;
			}
		}
		//表示这个节点的到底都没有环
		倒着将沿途的节点加入拓扑队列    //因为这是递归的返回,就是到头回来的过程
		return true;
	}
bool topoSort(){
	for(遍历节点){
		if(没访问过）{
			if(有环) return false;
		}
	}
	//所有节点都没环
	return true;
}

两句if 可以合成为 
if(没访问过 && 有环)return false;

核心代码如下：

bool dfs(int u)
{
    vis[u] = 1;
    for (int i = head[u]; i; i = edge[i].next) {
        int v = edge[i].to;
        if (vis[v] == 1) return false;
        if (vis[v] == 0 && !dfs(v)) return false;
    }
    vis[u] = -1;
    s.push(u);
    return true;
}

bool topsort(){
    mem(vis, 0);
    for(int i = n; i >= 1; --i){
        if(!vis[i]){
            if(!dfs(i))return false;
        }
    }
    return true;
}

如何按照字典序输出呢？

我们输出的时候是通过栈输出的，栈是先进后出，所以要想字典序最小，只需要让大的先进去，小的后进去，所以我们采用邻接链表的方法存图，存完图以后对每一个root节点的后续节点从大到小进行排序，这样dfs的时候，顺着取后继节点的时候就是从大到小。然后我们for循环的时候，也是从n开始到1去循环即可

#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <stdlib.h>
#include <sstream>
#include <map>
#include <set>
using  namespace std;
#define inf 0x3f3f3f3f
#define MAX 200000 + 50
#define endl '
'
#define seed 13331
#define mod 1000000000 + 7
#define io ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define mem(a,b) memset((a),(b),sizeof(a))
typedef  long long ll ;
//不开longlong见祖宗！
//inline __int128 read(){__int128 x = 0, f = 1;char ch = getchar();while(ch < '0' || ch > '9'){if(ch == '-'){f = -1;}ch = getchar();}while(ch >= '0' && ch <= '9'){x = x * 10 + ch - '0';ch = getchar();}return x * f;}
//inline void print(__int128 x){if(x < 0){putchar('-');x = -x;}if(x > 9){print(x / 10);}putchar(x % 10 + '0');}
inline int IntRead(){char ch = getchar();int s = 0, w = 1;while(ch < '0' || ch > '9'){if(ch == '-') w = -1;ch = getchar();}while(ch >= '0' && ch <= '9'){s = s * 10 + ch - '0';ch = getchar();}return s * w;}
inline void write(int x){if (x < 0) {x = ~x + 1; putchar('-');}if (x > 9){write(x / 10);}putchar(x % 10 + '0');}

int n, m, a, b, cnt;
vector<vector<int> >ma;
int vis[MAX];
stack<int>s;

bool cmp(int x, int y){
    return x > y;
}


bool dfs(int u){
    vis[u] = -1;
    for(int i = 0; i < ma[u].size(); ++i){
        if(vis[ma[u][i]] == -1)return false;
        else if(vis[ma[u][i]] == 0){
            dfs(ma[u][i]);
        }
    }
    vis[u] = 1;
    s.push(u);
    return true;
}

bool topsort(){
    mem(vis, 0);
    for(int i = n; i >= 1; --i){//从大的开始
        if(!vis[i]){
            if(!dfs(i))return false;
        }
    }
    return true;
}


int main(){
    n = IntRead();
    m = IntRead();
    ma = vector<vector<int> >(n + 1);//初始化
    for(int i = 1; i <= m; ++i){
        a = IntRead();
        b = IntRead();
        ma[a].push_back(b);
    }
    for(int i = 1; i <= n; ++i){//排序！
        sort(ma[i].begin(), ma[i].end(), cmp);
    }
    bool p = topsort();
    if(p == false)cout<<"IMPOSABLE
";
    else {
        while (s.size() != 1) {
                cout<<s.top()<<" ";
                s.pop();
            }
            cout<<s.top()<<endl;
    }
    return 0;
}

---

输出所有的拓扑序列

就是一个dfs，每次dfs都让入度为0且没有标记的点 i 去更新其后继节点，然后将 i 放进ans数组中，然后标记一下，去dfs(num + 1)，回溯的时候，就把所有更新的点的入度都加回来，把 i 重新标记为0。

#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <stdlib.h>
#include <sstream>
#include <map>
#include <set>
using  namespace std;
#define inf 0x3f3f3f3f
#define MAX 200000 + 50
#define endl '
'
#define seed 13331
#define mod 1000000000 + 7
#define io ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define mem(a,b) memset((a),(b),sizeof(a))
typedef  long long ll ;
//不开longlong见祖宗！
//inline __int128 read(){__int128 x = 0, f = 1;char ch = getchar();while(ch < '0' || ch > '9'){if(ch == '-'){f = -1;}ch = getchar();}while(ch >= '0' && ch <= '9'){x = x * 10 + ch - '0';ch = getchar();}return x * f;}
//inline void print(__int128 x){if(x < 0){putchar('-');x = -x;}if(x > 9){print(x / 10);}putchar(x % 10 + '0');}
inline int IntRead(){char ch = getchar();int s = 0, w = 1;while(ch < '0' || ch > '9'){if(ch == '-') w = -1;ch = getchar();}while(ch >= '0' && ch <= '9'){s = s * 10 + ch - '0';ch = getchar();}return s * w;}
inline void write(int x){if (x < 0) {x = ~x + 1; putchar('-');}if (x > 9){write(x / 10);}putchar(x % 10 + '0');}

int n, m, a, b, tot, now;
int head[MAX];
int in[MAX];
bool vis[MAX];
struct ran{
    int to, next;
}tr[MAX];
int ans[MAX];

void init(){
    mem(in, 0);
    mem(vis, 0);
    mem(tr, 0);
    mem(head, -1);
    tot = 0;
}

void built(int u, int v){
    tr[++tot].to = v;
    tr[tot].next = head[u];
    head[u] = tot;
}

void dfs(int num){
    if(num == n + 1){//如果数量到n+1，就输出
        for(int i = 1; i <= n; ++i){
            cout<<ans[i]<<' ';
        }
        cout<<endl;
    }
    for(int i = 1; i <= n; ++i){
        if(!in[i] && !vis[i]){//入度为0，且没被标记过
            int u = i;
            for(int j = head[u]; j != -1; j = tr[j].next){
                --in[tr[j].to];//遍历所有后继节点
            }
            vis[u] = 1;//标记一下点i
            ans[num] = u;//把他放进ans数组
            dfs(num + 1);//继续搜
            for(int k = head[u]; k != -1; k = tr[k].next){
                ++in[tr[k].to];
            }//把入度更新回来
            vis[u] = 0;//取消标记
        }
    }
    return;
}

int main(){
    io;
    while (cin>>n>>m && (n + m)) {
        init();
        for(int i = 1; i <= m; ++i){
            cin>>a>>b;
            built(a, b);
            ++in[b];
        }
        dfs(1);
    }
    return 0;
}