第一节——拓扑排序

已于 2023-08-23 20:09:41 修改
阅读量100 收藏
点赞数
分类专栏： C++ 文章标签： 算法 c++
于 2022-12-21 16:51:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_60600142/article/details/128397359
版权

第一节——拓扑排序

目录


本蒟蒻的第一篇文章，欢迎各位大佬来喷

一、前置知识

本文需要用到图、队列和邻接表的相关知识，不会的可以看看别人的，我找了几篇：
图
队列
链式前向星

二、拓扑排序

简介

拓扑排序是对一个有向图构造拓扑序列，解决工程是否能顺利进行的问题。构造时有 2 种结果：

1.此图全部顶点被输出：说明说明图中无「环」存在， 是 AOV 网
2.没有输出全部顶点：说明图中有「环」存在，不是 AOV 网
AOV（Activity On Vertex Network） ：一种 有向 无回路 的图

应用

举个例子，比如早上你起床，只能穿衬衫才能穿外衣，不能穿了外衣再穿衬衫。
生活中也有类似的情况，完成了A事才能完成B事，完成了C事才能完成D事，拓扑排序就是完成这类问题的。

代码实现

原理

为了方便理解，我画了个图

开始拓扑排序！
1.找入度为0的点，入队列；
2.不断从队头弹点，把有关的边全删掉，相邻的点入度减1，如果有点入度为0了，入队列；
3.如果队列弹没了，结束；
4.如果还有点的入度>0，就说明有环，没有答案。
过程：




注释：
1.节点上的方框代表这个节点上的入度；
2.连在一起的方框是队列；
因为言(wo)简(bi)意(jiao)赅(lan)，有些不删边的步骤我就省掉了

代码
#include<bits/stdc++.h>
#define PQG priority_queue < ll , vector < ll > , greater < ll > >
#define PQL priority_queue < ll , vector < ll > , less < ll > >
#define rep(i,s1,s2,s3) for(i = s1;i <= s2;i += s3)
#define r(i,s1,s2,s3) for(i = s1;i >= s2;i -= s3)
#define ULL_MAX numeric_limits < ull > :: max()
#define LL_MAX numeric_limits < ll > :: max()
#define rand_ srand(int(time(NULL)))
#define log(a,b) log(a) / log(b)
#define ull unsigned long long
#define NP next_pemurtation
#define sort stable_sort
#define INF 0x7f7f7f7f
#define ll long long 
using namespace std;
int n,m,id,in[100001],head[100001];
queue <int> ans;//答案
struct edge{//链式前向星
	ll u,v,next;
}e[100001];
void add(ll u,ll v){
	e[++id].v = v;
	e[id].u = u;
	e[id].next = head[u];
	head[u] = id;
}
inline ll re(){
    ll 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 << 1) + (x << 3) + (ch ^ 48);
        ch = getchar();
    }
    x *= f;
    return x;
}
inline void write(ll x){
	if (x < 0){putchar('-'); x = -x;}
	ull y = 10, len = 1;
	while (y <= x){y *= 10; len++;}
	while (len--){y /= 10; putchar(x / y + 48); x %= y;}
}
void top_sort(){
	queue <int> q;
	int i;
	rep(i,1,n,1) if(!in[i]) q.push(i),ans.push(i);
	while(!q.empty()){
		ll u = q.front(); q.pop();
		for(i = head[u];i;i = e[i].next){
			ll v = e[i].v; in[v]--;
			if(!in[v]) q.push(v),ans.push(v);
		}
	}
}
int main(){
	ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
	//freopen(".in","r",stdin);
	//freopen(".out","w",stdout);
	n = re(),m = re();
	int u,v;
	for(int i = 1;i <= m;i++){
		u = re(),v = re();
		add(u,v);//建边
		in[v]++;//入度增加
	}
	top_sort();
	while(!ans.empty()){
		write(ans.front());
		putchar(' ');
		ans.pop();
	} 
	return 0;
} 
//码风有一(亿)点点诡异

运行结果：
如果题目叫你输出字典序最小的答案呢？
很简单，我给你两种方法：
1.队列秒变小根堆

#include<bits/stdc++.h>
#define PQG priority_queue < ll , vector < ll > , greater < ll > >
#define PQL priority_queue < ll , vector < ll > , less < ll > >
#define rep(i,s1,s2,s3) for(i = s1;i <= s2;i += s3)
#define r(i,s1,s2,s3) for(i = s1;i >= s2;i -= s3)
#define ULL_MAX numeric_limits < ull > :: max()
#define LL_MAX numeric_limits < ll > :: max()
#define rand_ srand(int(time(NULL)))
#define log(a,b) log(a) / log(b)
#define ull unsigned long long
#define NP next_pemurtation
#define sort stable_sort
#define INF 0x7f7f7f7f
#define ll long long 
using namespace std;
int n,m,id,in[100001],head[100001];
queue <int> ans;
struct edge{
	ll u,v,next;
}e[100001];
void add(ll u,ll v){
	e[++id].v = v;
	e[id].u = u;
	e[id].next = head[u];
	head[u] = id;
}
inline ll re(){
    ll 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 << 1) + (x << 3) + (ch ^ 48);
        ch = getchar();
    }
    x *= f;
    return x;
}
inline void write(ll x){
	if (x < 0){putchar('-'); x = -x;}
	ull y = 10, len = 1;
	while (y <= x){y *= 10; len++;}
	while (len--){y /= 10; putchar(x / y + 48); x %= y;}
}
void top_sort(){
	PQG q = PQG ();
	int i;
	rep(i,1,n,1) if(!in[i]) q.push(i);
	while(!q.empty()){
		int u = q.top(); ans.push(u); q.pop();
		for(i = head[u];i;i = e[i].next){
			int v = e[i].v; in[v]--;
			if(!in[v]) q.push(v);
		}
	}
}
int main(){
	ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
	//freopen(".in","r",stdin);
	//freopen(".out","w",stdout);
	n = re(),m = re();
	int i,u,v;
	rep(i,1,m,1){
		u = re(),v = re();
		add(u,v); in[v]++;
	}
	top_sort();
	rep(i,1,n,1) if(in[i]){puts("-1"); return 0;}
	while(!ans.empty()){
		write(ans.front());
		ans.pop();
		putchar(' ');
	} 
	return 0;
}

运行结果：

2.反向建边+队列秒变大根堆+反着输出

#include<bits/stdc++.h>
#define PQG priority_queue < ll , vector < ll > , greater < ll > >
#define PQL priority_queue < ll , vector < ll > , less < ll > >
#define rep(i,s1,s2,s3) for(i = s1;i <= s2;i += s3)
#define r(i,s1,s2,s3) for(i = s1;i >= s2;i -= s3)
#define ULL_MAX numeric_limits < ull > :: max()
#define LL_MAX numeric_limits < ll > :: max()
#define rand_ srand(int(time(NULL)))
#define log(a,b) log(a) / log(b)
#define ull unsigned long long
#define NP next_pemurtation
#define sort stable_sort
#define INF 0x7f7f7f7f
#define ll long long 
using namespace std;
int n,m,id,in[100001],head[100001];
stack <int> ans;
struct edge{
	ll u,v,next;
}e[100001];
void add(ll u,ll v){
	e[++id].v = v;
	e[id].u = u;
	e[id].next = head[u];
	head[u] = id;
}
inline ll re(){
    ll 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 << 1) + (x << 3) + (ch ^ 48);
        ch = getchar();
    }
    x *= f;
    return x;
}
inline void write(ll x){
	if (x < 0){putchar('-'); x = -x;}
	ull y = 10, len = 1;
	while (y <= x){y *= 10; len++;}
	while (len--){y /= 10; putchar(x / y + 48); x %= y;}
}
void top_sort(){
	PQL q = PQL ();
	int i;
	rep(i,1,n,1) if(!in[i]) q.push(i);
	while(!q.empty()){
		int u = q.top(); ans.push(u); q.pop();
		for(i = head[u];i;i = e[i].next){
			int v = e[i].v; in[v]--;
			if(!in[v]) q.push(v);
		}
	}
}
int main(){
	ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
	//freopen(".in","r",stdin);
	//freopen(".out","w",stdout);
	n = re(),m = re();
	int i,u,v;
	rep(i,1,m,1){
		u = re(),v = re();
		add(v,u); in[u]++;
	}
	top_sort();
	rep(i,1,n,1) if(in[i]){puts("-1"); return 0;}
	while(!ans.empty()){
		write(ans.top());
		ans.pop();
		putchar(' ');
	} 
	return 0;
}

运行结果：

三、推荐几个题目

P1038、P1137、P1347、P1807、P1983。
其他题目到洛谷上搜索吧！

Holiday1314
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【18】输出字符菱形
2301_78786609的博客
07-19 384
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 333
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
算法题目整合5
最新发布
qq_62571233的博客
07-23 636
思路：利用left和right记录连续相同的字符串索引，计算长度len，如果是0,1,2,4这种情况直接输出-1并return。如果是奇数直接输出，如果是偶数的话，可以拆成3和len-3两个部分。的最小值是101100，求其第4554小即在从后数的四个问号位置分别加上‘3’，‘5’，‘5’，‘4’即可，即551153；表示当前卡牌正面（或反面）加上上一个取余结果再对3取余的值，举个例子，比如说。），由于不同的取余方案搭配上正反面的组合，共有6中结果，所以在。，表示当前卡牌正面为1，当遍历的。
【Hot100】LeetCode—152. 乘积最大子数组
weixin_44382896的博客
07-23 130
【代码】【Hot100】LeetCode—152. 乘积最大子数组。
插入和选择排序
c23856的博客
07-20 452
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
2024.7.19 刷题总结
TheJustice_的博客
07-19 250
543.二叉树的直径，这道题是一道考察递归的题目，按照树的一般算法，维护一个最大直径答案值，定义一个递归函数，开头是递归返回条件，即当前节点为空节点就返回0，否则分别往左和往右递归，维护每个节点的最大深度为左右最大深度中的最大值再加一，答案用左右节点的最大深度的和再加一来维护.124.二叉树中的最大路径和，这是一道考察递归的题目，从根节点出发，类似于dfs，分别递归寻找左右节点的路径和，直到叶子节点再返回，从叶子节点往上更新以每个节点为根节点的最大路径，直到返回根节点，用一个变量来维护答案.
完全二叉树的节点个数-递归
qq_45031559的博客
07-19 270
完全二叉树的节点个数-递归
python实现图像缩放算法
qq_42568323的博客
07-20 345
它通过选择离目标像素最近的原始像素的颜色值来确定目标像素的颜色值。它通过考虑目标像素周围16个像素的颜色值，使用双三次插值公式计算出目标像素的颜色值。相较于双线性插值，双三次插值能生成更平滑、更细腻的图像效果。它通过考虑目标像素周围四个像素的颜色值，使用双线性插值公式计算出目标像素的颜色值。尽管最近邻插值在某些应用场景中足够使用，但在需要更高质量图像的场景中，通常会选择更加复杂的插值方法，如双线性插值或双三次插值。双三次插值是图像缩放中高质量的方法之一，适合需要高质量图像处理的应用场景。
傻瓜图解 -- 算法刷题之路之链表初探（八 ）旋转链表
aoyuanyuan0921的博客
07-19 190
今天来学习的算法题是leecode61旋转链表，是一道简单的入门题，话不多说！原子本来写了一大推书面解释！我直接上图，如果有疑问的话私信我交流一下！
【刷题汇总 -- 压缩字符串(一)、chika和蜜柑、 01背包】
m0_69455439的博客
07-19 1140
今日刷题汇总day018 -- 压缩字符串(一)、chika和蜜柑、 01背包
算法第十一天：leetcode707.设计链表
m0_75068978的博客
07-19 1454
的链接如下表所示，您可直接复制下面网址进入力扣学习，在观看下面的内容之前一定要先做一遍哦，这样才能印象深刻！题目描述：你可以选择使用单链表或者双链表，设计并实现自己的链表。val和next。val是当前节点的值，next是指向下一个节点的指针/引用。如果是双向链表，则还需要属性prev以指示链表中的上一个节点。假设链表中的所有节点下标从开始。实现index-1valvalvalindexindexindexindex// 链表变为 1->2->3// 返回 2。
算法之选择排序
SmileAssassn的博客
07-20 343
什么是选择排序呢，就是给你一组无序数组，进行排序，那么从第一个数开始，依次与后面的数进行比较，如果找到最小的，就放在第一位，然后从第二个再进行比较，放在第二个，重复以上操作，直到找到最后一个数，这样就完成了由小到大的一个排序，由大到小也是一样的。本来的想法是找到一个最小的，直接从原来的数组中删除，然后放到新的数组中就好了，但是由于java中的数组删除一个数很麻烦，因此这边直接需要新建个swap方法，专门用来进行数组中的数进行交换使用。输入一组无序数组，然后进行从小到大的排序，并输出最后的结果。
Java实现七大排序（二）
lllsure的博客
07-23 356
冒泡排序、快速排序、归并排序
上海市计算机学会竞赛平台2022年9月月赛丙组二叉树的遍历
a121677_的博客
07-20 199
有一棵二叉树，结点数量不超过 2626 个，树上的每个结点都有一个大写字母。给定这棵二叉树的前序遍历及中序遍历，请输出它的后序遍历。设输入的字符串长度为 𝑛n，
Codeforces Round 959 (Div. 1 + Div. 2 ABCDEFG 题) 文字讲解+视频讲解
Edward Shi的博客
07-20 718
Codeforces Round 959 (Div. 1 + Div. 2 ABCDEFG 题) 文字讲解+视频讲解
《算法笔记》总结No.9——高效配招
前端，算法，MATLAB，统计学爱好者，目前主攻Web全栈+考研内容
07-20 411
而如果进行预处理，即把所有Fibonacci数预先计算并存在数组中，那么每次查询就只需要O(1)的时间复杂度，对Q次查询就只需要O（n+Q）的时间复杂度(其中O(n)是预处理的时间)。这种用法般是当程序的一部分过程消耗的时间过多，或是没有想到好的算法，因此在另一个程序中使用暴力算法求出结果，这样就能直接在原程序中使用这些结果。例如对皇后问题来说，如果使用的算法不够好，就容易超时，而可以在本地用程序计算出对所有来说2皇后问题的方案数，然后把算出的结果直接写在数组中，就可以根据题目输入的来直接输出结果。
使用Python实现决策树算法：从数据导入到模型评估
2401_85639015的博客
07-20 360
通过本教程，您已经学习了如何使用Python和Scikit-Learn实现决策树算法，从数据导入、数据预处理、模型构建、训练到模型评估和可视化。决策树算法具有直观、易解释的优点，但在实际应用中可能会过拟合。未来，您可以尝试使用剪枝技术、集成学习（如随机森林和梯度提升树）来优化决策树模型，提升其泛化能力和预测性能。希望本教程能帮助您在机器学习和数据分析领域取得更大进步！
牛客14666(优先屏障) + 牛客14847(Masha与老鼠)
wh233z的博客
07-23 151
昨天刷的这两道题写了很久·····，特别是Masha与老鼠这道题，写了都快3个小时，主要还是理解代码逻辑有点难，不过写完之后感觉收获挺大的，给我以后刷题提供很好的思路。
2024秋招算法
weixin_43364551的博客
07-22 940
根据代码随想录和力扣进行算法训练的笔记
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值