图论——拓补排序

在CSP初赛基本信息(书接上回)这篇文章中，就已经对拓补排序做了一个概念性的解释(做诠释)，但是本蒟蒻昨天写一个拓补排序的模板写了很久，所以写这一篇来记录一下拓补排序

还是先上概念：

拓扑排序是一种对有向无环图（DAG）进行排序的算法。

它的主要思想是：对于一个有向无环图，选择一个入度为 0 的顶点并将其输出，然后删除该顶点以及与其相关的边，重复这个过程，直到图中所有顶点都被输出。

以下是一个简单的拓扑排序的示例：

假设有一个有向无环图，顶点表示任务，边表示任务之间的先后关系。

顶点：A、B、C、D、E

边：A -> B，A -> C，B -> D，C -> D，D -> E

首先，找到入度为 0 的顶点，即 A 。输出 A ，然后删除 A 及其相关的边，此时 B 和 C 的入度变为0 。接着，选择 B 输出，删除 B 及其相关的边，此时 D 的入度变为 0 。然后，输出 C ，再输出 D ，最后输出 E ，完成拓扑排序。需要注意的是，如果一个图不是有向无环图，那么就无法进行拓扑排序。

模板题：

洛谷传送门：B3644 【模板】拓扑排序 / 家谱树 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn) 

为什么要使用拓补排序？

一、问题本身的特点

• 家族关系的依赖性：题目描述了一个家族中成员之间的辈分关系，特别是后代与前代之间的依赖关系。这种关系是有向的，即后代依赖于前代的存在。
• 无环性：在家族关系中，通常不会出现环状的依赖，即一个人不能是自己的后代或祖先，这保证了家族关系图是一个有向无环图（DAG）。

二、拓扑排序本身

• 处理有向无环图中的依赖关系：拓扑排序正是为了处理有向无环图中节点之间的依赖关系而设计的。它能够将图中的节点排序，使得对于每一条有向边(u, v)，节点u都在节点v之前。
• 生成满足条件的序列：题目要求输出一个序列，使得每个人的后辈都比那个人后列出。这正是拓扑排序能够解决的问题，因为拓扑排序的结果就是一个满足所有依赖关系的线性序列。

所以，拓补排序解决的问题就是 ：

1. 每个顶点在序列中出现且仅出现一次：确保序列中的每个顶点都是唯一的，不会重复出现。
2. 若存在一条从顶点A到顶点B的路径，则顶点A在序列中出现在顶点B的前面：这保证了序列中的顶点顺序反映了原图中顶点之间的依赖关系或前驱后继关系。

例子：

• 任务调度：在任务调度中，任务之间往往存在依赖关系，如任务A完成后才能开始任务B。拓扑排序可以用来确定任务的执行顺序，确保依赖关系得到满足。
• 课程安排：在学校的课程安排中，一些课程可能需要先修课程作为基础。拓扑排序可以用来确定课程的学习顺序，确保学生按照正确的顺序完成课程。
• 项目管理：在项目管理中，一个大型项目往往需要分解成多个子项目或任务，并且这些子项目或任务之间存在依赖关系。拓扑排序可以用来确定子项目或任务的执行顺序，确保依赖关系得到满足。

拓扑排序的具体实现方法有多种，如深度优先搜索（DFS）算法结合入度数组的方式。这些方法的核心思想都是通过不断选择入度为0的节点进行排序，并更新剩余节点的入度，直到所有节点都被排序或图中不存在入度为0的节点（后者表示图中存在环，但拓扑排序仅适用于有向无环图）。

下面捋一捋具体的过程：

1.存图，统计每个点的入度

2.遍历，把整张图所有入度为0的点从队尾入队

3.输出、出队和删边，每列出一个节点后，需要将其从图中删除，并且自身的入度-1,并删除所有指向该节点的边。

4.遍历直到所有边入度都为0或全部被排序：最值得注意的就是不要重复入队，会死循环

下面来看一下模板题的做法：

首先，数据范围是100，于是可以用邻接矩阵存图，代码解释在注释里

#include<bits/stdc++.h>
using namespace std;
int n;
int a[300][300];//邻接矩阵
int r[300];//r[i]表示i这个点的入度
bool vis[300];//标记是否入队，防止死循环
queue<int>q;//拓补排序的队列
int main(){
	cin>>n;
    //初始化邻接矩阵
	for(int i=0;i<=200;i++){
		for(int j=0;j<=200;j++){
			a[i][j]=-1;
		}
	}
    //邻接矩阵存图
	for(int i=1;i<=n;i++){
		while(true){
			int x;
			cin>>x;
			if(x==0){
				break;
			}
			r[x]++;
			a[i][x]=1;
		}
	}
    //遍历r(即入度数组)，找到所有入度为0的点并将其入队和标记
	for(int i=1;i<=n;i++){
		if(r[i]==0){
			q.push(i);
			vis[i]=1;
		}
	}
    //队列非空，证明还有点没有处理
	while(!q.empty()){
		int x=q.front();//取队首
		cout<<x<<" ";//输出
		q.pop();//出队
		for(int i=1;i<=n;i++){//删除整个图里所有和这个已经处理好的点(即这个如为0的点)的边
			if(a[x][i]==1){
				a[x][i]=0;
				r[i]--;
			}
		}
		for(int i=1;i<=n;i++){//再循环，把所有未入队的入度为0的点入队并标记
			if(r[i]==0&&vis[i]==0){
				q.push(i);
				vis[i]=1;
			}
		}
	}	
	return 0;
}

邻接矩阵这道题是可以，但是邻接表更为常用。下面展示一下某位神犇的邻接表的代码

#include<bits/stdc++.h>
using namespace std;
inline int read(){
	char w=getchar();
	int fl=1,sum=0;
	while(w>'9'||w<'0'){if(w=='-')fl=-1;w=getchar();}
	while(w<='9'&&w>='0'){sum=(sum<<1)+(sum<<3)+(w^48);w=getchar();}
	return fl*sum;
}
string read_s() {
    string result;
    char w;
    while((w=getchar())!=EOF){
    	if(w=='\n') break;
        result+=w;
    }
    return result;
}
int to[300],ne[300],head[300],rd[300];
queue<int>q;
int idx,n;
void add(int x,int y){
	to[++idx]=y;
	ne[idx]=head[x];
	head[x]=idx;
}


int main(){
	n=read();
	for(int i=1;i<=n;i++){
		int x=read();
		while(x!=0){
			add(i,x);
			rd[x]++;
			x=read();
		}
	}
	for(int i=1;i<=n;i++){
		if(!rd[i]) q.push(i);
	}
	while(!q.empty()){
		int x=q.front();
		q.pop();
		cout<<x<<" ";
		for(int i=head[x];i;i=ne[i]){
			rd[to[i]]--;
			if(rd[to[i]]==0){
				q.push(to[i]);
			}
		}
	}
	return 0;
}
//假设在全局或类的成员变量中定义了以下数组或向量  
// int head[MAXN]; // 用于存储每个顶点的第一条邻接边的索引，初始化为-1或0（取决于实现）  
// int to[MAXE];   // 存储边的终点  
// int ne[MAXE];   // 存储边的下一个邻接边的索引，形成链表结构  
// int idx = 0;    // 边的索引，用于向to和ne数组中添加新的边  
//  
//void add(int u, int v) {  
//    to[++idx] = v;    // 将当前边的终点v存储在to数组的下一个位置  
//    ne[idx] = head[u]; // 将当前顶点u的head值（即u的第一条邻接边的索引）赋给ne[idx]，  
//                       // 这样ne[idx]就指向了u的原本的第一条邻接边  
//    head[u] = idx;    // 更新u的head值，使其指向新添加的这条边，即u的新的第一条邻接边  
//}
//head[1] = 1; 表示顶点1的第一条邻接边现在存储在 to 数组的第1个位置
//链表头是起点，后面的节点表示边，边储存边长和终点