什麼是拓撲排序？
先穿襪子再穿鞋，先當孫子再當爺。這就是拓撲排序！
拓撲排序說白了其實不太算是一種排序演算法，但又像是一種排序（我是不是說了個廢話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 '\n'
#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 '\n'
#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 '\n'
#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\n";
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 '\n'
#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 '\n'
#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\n";
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 '\n'
#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;
}