图论——拓扑排序

1、什么是拓扑排序

（1）有向图的拓扑序列

有向图的拓扑序列是该有向图的一个顶点序列，该序列满足条件：对图中任意顶点i、j，若从顶点i到顶点j存在一条路径，则在序列中顶点i必须排在顶点j的前面。

（2）拓扑排序

在一个有向图中找一个拓扑序列的过程称为拓扑排序。

2、拓扑排序的应用

拓扑排序常用来确定一个依赖关系集中，事物发生的顺序。例如，在日常工作中，可能会将项目拆分成A、B、C、D四个子部分来完成，但A依赖于B和D，C依赖于D。为了计算这个项目进行的顺序，可对这个关系集进行拓扑排序，得出一个线性的序列，则排在前面的任务就是需要先完成的任务。

注意：一个有向图的拓扑序列不是唯一的！就好像你早上穿衣服可以先穿上衣也可以先穿裤子，只要里面的衣服在外面的衣服之前穿就行。

3、拓扑排序算法的实现

拓扑排序的基本思想是，每次寻找图中一个入度为0的顶点输出，然后删除该顶点指向的边，依次寻找剩余顶点，直到没有入度为0的顶点为止。算法的执行步骤如下：

①寻找图中一个入度为0的顶点输出，然后删除该顶点指向的边。

②重复步骤①，直到没有入度为0的顶点为止。

代码实现：

#define N 100
typedef char ElemType;

/*
拓扑图的邻接矩阵声明
*/
typedef struct _MGraph
{
	int n;
	ElemType vertexes[N];
	int edges[N][N];
}MGraph;

/*
拓扑排序：生成拓扑图第一个拓扑序列
g：拓扑图的邻接矩阵
*/
void TopSort(MGraph &g)
{
	int *count = new int[g.n]();
	for (int i = 0; i < g.n; i++)
	{
		for (int j = 0; j < g.n; j++)
		{
			if (g.edges[i][j] > 0)
				count[j]++;
		}
	}
	queue<int> q;
	for (int i = 0; i < g.n; i++)
	{
		if (count[i] == 0)
			q.push(i);
	}
	while (!q.empty())
	{
		int i = q.front();
		cout << g.vertexes[i];
		q.pop();
		for (int j = 0; j < g.n; j++)
		{
			if (g.edges[i][j] > 0)
			{
				count[j]--;
				if (count[j] == 0) q.push(j);
			}
		}
	}
	delete[] count;
}

4、测试

求如下图所示的有向图的全部可能的拓扑序列。

样例输入：

6 6
0 1 2 3 4 5
0 1
1 2
2 3
4 1
4 5

5 3

样例输出：

041523
041253
045123
405123
401523
401253

450123

测试代码：

#include <iostream>
#include <vector>
#include <queue>
using namespace std;

#define N 100
typedef char ElemType;

/*
拓扑图的邻接矩阵声明
*/
typedef struct _MGraph
{
	int n;
	ElemType vertexes[N];
	int edges[N][N];
}MGraph;

/*
拓扑排序：生成拓扑图第一个拓扑序列
g：拓扑图的邻接矩阵
*/
void TopSort(MGraph &g)
{
	int *count = new int[g.n]();
	for (int i = 0; i < g.n; i++)
	{
		for (int j = 0; j < g.n; j++)
		{
			if (g.edges[i][j] > 0)
				count[j]++;
		}
	}
	queue<int> q;
	for (int i = 0; i < g.n; i++)
	{
		if (count[i] == 0)
			q.push(i);
	}
	while (!q.empty())
	{
		int i = q.front();
		cout << g.vertexes[i];
		q.pop();
		for (int j = 0; j < g.n; j++)
		{
			if (g.edges[i][j] > 0)
			{
				count[j]--;
				if (count[j] == 0) q.push(j);
			}
		}
	}
	delete[] count;
}

void TopSortInit(MGraph &g, int count[], vector<int> &v)
{
	memset(count, 0, sizeof(int) * g.n);
	for (int i = 0; i < g.n; i++)
	{
		for (int j = 0; j < g.n; j++)
		{
			if (g.edges[i][j] > 0)
				count[j]++;
		}
	}
	for (int i = 0; i < g.n; i++)
	{
		if (count[i] == 0)
		{
			v.push_back(i);
		}
	}
}

void TopSort(MGraph &g, int count[], vector<int> &v, vector<ElemType> &result)
{
	if (v.size() == 0)
	{
		for (vector<ElemType>::iterator iter = result.begin(); iter != result.end(); iter++)
			cout << *iter;
		cout << endl;
	}
	for (vector<int>::iterator iter = v.begin(); iter != v.end(); iter++)
	{
		int i = *iter;
		vector<int> v_new = v;
		result.push_back(g.vertexes[i]);
		v_new.erase(iter - v.begin() + v_new.begin());
		for (int j = 0; j < g.n; j++)
		{
			if (g.edges[i][j] > 0)
			{
				count[j]--;
				if (count[j] == 0) v_new.push_back(j);
			}
		}
		TopSort(g, count, v_new, result);
		result.pop_back();
		for (int j = 0; j < g.n; j++)
		{
			if (g.edges[i][j] > 0)
			{
				count[j]++;
			}
		}
	}
}

int main()
{
	int n, m;
	while (cin >> n >> m)
	{
		//输入数据
		MGraph g;
		g.n = n;
		for (int i = 0; i < g.n; i++)
			cin >> g.vertexes[i];
		for (int i = 0; i < g.n; i++)
			for (int j = 0; j < g.n; j++)
				g.edges[i][j] = 0;
		for (int cnt = 0; cnt < m; cnt++)
		{
			int u, v;
			cin >> u >> v;
			g.edges[u][v] = 1;
		}
		//求出第一个拓扑序列
		//TopSort(g);
		//求出所有可能的拓扑序列
		int *count = new int[g.n];
		int *visited = new int[g.n];
		vector<int> v;
		vector<ElemType> r;
		TopSortInit(g, count, v);
		TopSort(g, count, v, r);
		delete[] count, visited;
	}
	//while (1) cin.get();
	return 0;
}

参考资料

[1] 李春葆.数据结构教程.清华大学出版社，2013.

[2]拓扑排序.百度百科.