拓扑排序（算法笔记）

本文内容基于《算法笔记》和官方配套练题网站“晴问算法”，是我作为小白的学习记录，如有错误还请体谅，可以留下您的宝贵意见，不胜感激。

---

一、有向无环图

如果一个有向图的任意顶点都无法通过一些有向边回到自身，那么称这个有向图为有向无环图(Directed Acyclic Graph,DAG)。

二、拓扑排序

1.概念： 拓扑排序是将有向无环图G的所有顶点排成一个线性序列，使得对图G中的任意两个顶点u、v，如果存在边u->v，那么在序列中u一定在v前面。这个序列又被称为拓扑序列。
**2.规律：**从概念可知，若要生成某个顶点在拓扑排序序列中的位置，就必须保证该顶点的前驱结点已经被访问完毕，转化为图的语言表示就是该顶点的入度为0，即没有可以到达该顶点的前驱结点。对于不存在直接或者间接前驱关系的顶点之间的顺序可以任意，如果题目有要求，就按照要求进行排序。
3.实现方法：
（1）定义队列Q，并把所有入度为0的结点加入队列；（其实并不是必须需要队列）
（2）取队首节点，输出。然后删去所有从它出发的边，并令这些边到达的所有顶点的入度减1，如果某个顶点的入度减为0，则将其加入队列。
（3）反复进行（2）操作，直到队列为空。如果队列为空时入过队的结点数目恰好为N，说明拓扑排序成功，图G为有向无环图；否则，拓扑排序失败，图G中又环。
如何证明如果存在环，则环内的元素无法加入队列中呢？其实可以把环简化为以下的表现形式：

可以看到，如果要让顶点Vi入队，则必须消除它的前导关系，但它是以自己为前导的，也就是说除非这个顶点消失，否则这个前导关系永远不会消失，显然这个顶点永远都不会加入到拓扑序列中去。

三、小题练习

1.拓扑排序

由于题中明确在选择入度为0的顶点时，总是选择编号最小的顶点，属于动态更新数据流的最值问题，采用优先级队列实现。
完整代码如下：

//只能说bfs和拓扑排序的实现依赖队列，但不能把他们混为一谈，就和分治和递归技术的关系一样 
#include<cstdio>
#include<queue>
#include<vector>
using namespace std;

const int MAXN = 100;
vector <int> Adj[MAXN];
int inDegree[MAXN] = {};    //散列结点的入度 
int n , m;

struct cmp{
	bool operator ()(int a , int b){
		return a > b;
	}
};

void topological_sort(){
	int num = 0;
	priority_queue <int , vector<int> , cmp> pq;   //记录入度为0的结点
	for(int i = 0; i < n; i++)
		if(inDegree[i] == 0) pq.push(i);
	while(!pq.empty()){
		int u = pq.top();
		pq.pop();
		printf("%d", u);
		if(num < n - 1) printf(" ");
		for(int i = 0; i < Adj[u].size(); i++){
			int v = Adj[u][i];
			inDegree[v]--;
			if(inDegree[v] == 0) pq.push(v); 
		}
		num++;
	}
}

int main(){
	scanf("%d%d", &n , &m);
	for(int i = 0; i < m; i++){
		int u , v;
		scanf("%d%d", &u , &v);
		Adj[u].push_back(v);
		inDegree[v]++; 
	}
	topological_sort();
}

2.有向无环图的判定——拓扑排序

完整代码如下：

//只能说bfs和拓扑排序的实现依赖队列，但不能把他们混为一谈，就和分治和递归技术的关系一样 
#include<cstdio>
#include<queue>
#include<vector>
using namespace std;

const int MAXN = 100;
vector <int> Adj[MAXN];
int inDegree[MAXN] = {};    //散列结点的入度 
int n , m;

struct cmp{
	bool operator ()(int a , int b){
		return a > b;
	}
};

bool topological_sort(){
	int num = 0;
	priority_queue <int , vector<int> , cmp> pq;   //记录入度为0的结点
	for(int i = 0; i < n; i++)
		if(inDegree[i] == 0) pq.push(i);
	while(!pq.empty()){
		int u = pq.top();
		pq.pop();
		for(int i = 0; i < Adj[u].size(); i++){
			int v = Adj[u][i];
			inDegree[v]--;
			if(inDegree[v] == 0) pq.push(v); 
		}
		num++;
	}
	if(num == n) return true;
	else return false;
}

int main(){
	scanf("%d%d", &n , &m);
	for(int i = 0; i < m; i++){
		int u , v;
		scanf("%d%d", &u , &v);
		Adj[u].push_back(v);
		inDegree[v]++; 
	}
	if(topological_sort()) printf("Yes");
	else printf("No");
}

3.先导课程
保存拓扑序列即可，从上面的证明可以知道环内的结点永远不会加入到拓扑序列中，结点数减去拓扑序列中的结点数量即为环内结点数量，即不能学习的课程门数。
完整代码如下：

//只能说bfs和拓扑排序的实现依赖队列，但不能把他们混为一谈，就和分治和递归技术的关系一样 
#include<cstdio>
#include<queue>
#include<vector>
using namespace std;

const int MAXN = 100;
vector <int> Adj[MAXN];
vector <int> topo;
int inDegree[MAXN] = {};    //散列结点的入度 
int n , m;

struct cmp{
	bool operator ()(int a , int b){
		return a > b;
	}
};

int topological_sort(){
	int num = 0;
	priority_queue <int , vector<int> , cmp> pq;   //记录入度为0的结点
	for(int i = 0; i < n; i++)
		if(inDegree[i] == 0) pq.push(i);
	while(!pq.empty()){
		int u = pq.top();
		pq.pop();
		topo.push_back(u); 
		for(int i = 0; i < Adj[u].size(); i++){
			int v = Adj[u][i];
			inDegree[v]--;
			if(inDegree[v] == 0) pq.push(v); 
		}
		num++;
	}
	if(num == n) return 0;  //可以全部学完，剩余0门未学课程 
	else return n - num;    //不能全部学完，剩余n-num门未学课程 
}

int main(){
	scanf("%d%d", &n , &m);
	for(int i = 0; i < m; i++){
		int u , v;
		scanf("%d%d", &u , &v);
		Adj[u].push_back(v);
		inDegree[v]++; 
	}
	int num = topological_sort();
	if(num == 0) {
		printf("Yes\n");
		for(int i = 0; i < topo.size(); i++){
			printf("%d", topo[i]);
			if(i + 1 < topo.size()) printf(" ");
		}
	}
	else {
		printf("No\n%d", num);
	}
}