915-拓扑排序的几种实现方式以及变形

已于 2023-12-23 19:20:43 修改
阅读量962 收藏 17
点赞数 25
分类专栏： 西交软件915 文章标签： 算法 数据结构 c++
于 2023-12-20 23:53:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46105528/article/details/135120263
版权

这里给大家总结一下拓扑排序的几种写法或变形：用栈、用队列、基于宽搜、基于深搜、915-23 真题中的改编 topsort 求 level（DAG的最大高度）。

AcWing. 848. 有向图的拓扑序列
Xnip2023-12-20_23-49-32.png

1.基于宽搜的topsort

下面这段代码使用拓扑排序来解决有向图的问题。拓扑排序是一种对有向无环图进行排序的算法，其基本思想是通过顶点之间的有向边的方向来排序，保证在排序结果中，任意一对有向边的起点在终点之前。

具体步骤如下：

  1. 统计每个节点的入度（in-degree），入度表示有多少条边指向该节点。
  2. 将入度为0的节点加入队列。
  3. 对队列中的节点进行遍历，将其邻接节点的入度减1。如果邻接节点入度为0，则加入队列。
  4. 重复步骤3，直到队列为空。
  5. 判断拓扑排序是否成功，即队列中的节点个数是否等于图的节点个数。如果等于，说明有合法的拓扑序列。

如果拓扑排序成功，输出拓扑排序的结果；否则，输出"-1"表示图中存在环，无法进行拓扑排序。

#include <iostream>

using namespace std;

const int N = 100010;

int n, m;
int d[N]; // 入度数组，记录每个节点的入度
int q[N], hh = 0, tt = -1; // 队列，hh 表示队头，tt 表示队尾

struct Node
{
    int id;
    Node *next;
    Node(int x) : id(x), next(NULL) {}
} *head[N]; // 邻接表存储图的边信息

void add(int a, int b)
{
    Node *p = new Node(b);
    p->next = head[a];
    head[a] = p;
}

bool bfs()
{
    // 将入度为 0 的节点加入队列
    for (int i = 1; i <= n; i++)
        if (!d[i])
            q[++tt] = i;

    while (hh <= tt)
    {
        int t = q[hh++];

        for (Node *p = head[t]; p; p = p->next)
        {
            int j = p->id;
            if (--d[j] == 0)
                q[++tt] = j;
        }
    }

    // 如果队列中的节点个数等于图的节点个数，说明拓扑排序成功
    return tt == n - 1;
}

int main()
{
    cin >> n >> m;
    while (m--)
    {
        int a, b;
        cin >> a >> b;
        add(a, b);
        d[b]++; // 记录每个节点的入度
    }

    if (!bfs())
        puts("-1");
    else
    {
        // 输出拓扑排序的结果
        for (int i = 0; i < n; i++)
            cout << q[i] << ' ';
        cout << endl;
    }

    return 0;
}

Xnip2023-12-20_23-24-39.png

2.将队列改为栈进行拓扑排序

有同学说将队列改为栈后再进行拓扑排序输出的是逆拓扑序列，这句话是错的，这里用代码给大家验证一下。

将队列改为栈之后要做的改变：需要新增拓扑排序的结果数组res来保存每次出栈元素。
其余过程一样。最后输出结果仍为拓扑有序序列。

下图来自《数据结构 C语言版 第2版 (严蔚敏)》
Xnip2023-12-20_23-16-59.png
Xnip2023-12-20_23-17-28.png

#include <iostream>
#include <queue>

using namespace std;

const int N = 100010;

int n, m;
int d[N];
int stk[N], top = -1;   // 用栈存储入度为0的节点
int res[N], k;

struct Node
{
    int id;
    Node *next;
    Node(int x) : id(x), next(NULL) {}
} *head[N]; // 邻接表存储图的边信息

void add(int a, int b)
{
    Node *p = new Node(b);
    p->next = head[a];
    head[a] = p;
}

// 拓扑排序
bool topsort()
{
    // 将入度为0的节点入栈
    for (int i = 1; i <= n; i++)
        if (!d[i])
            stk[++top] = i;

    while (top > -1)
    {
        int t = stk[top--];
        res[k++] = t; // 将当前节点加入结果数组

        for (Node *p = head[t]; p; p = p->next)
        {
            int j = p->id;
            if (--d[j] == 0)
                stk[++top] = j; // 将入度为0的相邻节点入栈
        }
    }

    return k == n; // 如果结果数组中节点个数等于图中节点个数，说明拓扑排序成功
}

int main()
{
    cin >> n >> m;
    while (m--)
    {
        int a, b;
        cin >> a >> b;
        add(a, b);
        d[b]++; // 统计每个节点的入度
    }

    if (!topsort())
        puts("-1"); // 无法进行拓扑排序，图中有环
    else
    {
        for (int i = 0; i < n; i++)
            cout << res[i] << ' ';
        cout << endl;
    }

    return 0;
}

Xnip2023-12-20_23-23-22.png

3.915-23 真题中的改编 topsort 求 level（DAG的最大高度）

Xnip2023-12-20_23-11-36.png

#include <iostream>

using namespace std;

const int N = 100010;

int n, m;
int d[N]; // 入度数组，记录每个节点的入度
int q[N], hh = 0, tt = -1; // 队列，hh 表示队头，tt 表示队尾
int level[N];   // 存每个结点的level

struct Node
{
    int id;
    Node *next;
    Node(int x) : id(x), next(NULL) {}
} *head[N]; // 邻接表存储图的边信息

void add(int a, int b)
{
    Node *p = new Node(b);
    p->next = head[a];
    head[a] = p;
}
bool bfs()
{
    // 将入度为 0 的节点加入队列
    for (int i = 1; i <= n; i++)
        if (!d[i])
            q[++tt] = i;

    while (hh <= tt)
    {
        int t = q[hh++];

        for (Node *p = head[t]; p; p = p->next)
        {
            int j = p->id;
            if (--d[j] == 0)
            {
                // level 为指向该结点的所有结点中最大的 level + 1
                level[j] = max(level[j], level[t] + 1);
                q[++tt] = j;
            }
        }
    }

    // 如果队列中的节点个数等于图的节点个数，说明拓扑排序成功
    return tt == n - 1;
}

int main()
{
    cin >> n >> m;
    while (m--)
    {
        int a, b;
        cin >> a >> b;
        add(a, b);
        d[b]++; // 记录每个节点的入度
    }

    if (!bfs())
        puts("-1");
    else
    {
        // 输出拓扑排序的结果
        for (int i = 0; i < n; i++)
            cout << q[i] << ' ';
        cout << endl;
        // 输出level的结果
        for (int i = 1; i <= n; i++)
            cout << level[i] << ' ';
        cout << endl;
    }

    return 0;
}

4.基于深搜的topsort

4.1求逆拓扑有序序列

该代码的前提是保证图存在拓扑序列。

#include <iostream>

using namespace std;

const int N = 100010;

int n, m;
bool st[N]; // 标记每个点是否被访问过
int d[N]; // 入度数组，记录每个节点的入度

struct Node
{
    int id;
    Node *next;
    Node(int x) : id(x), next(NULL) {}
} *head[N]; // 邻接表存储图的边信息

void add(int a, int b)
{
    Node *p = new Node(b);
    p->next = head[a];
    head[a] = p;
}

void dfs(int u)
{
    st[u] = true;   // 将当前结点标记为已访问
    
    // 遍历当前结点的邻接点
    for (Node *p = head[u]; p; p = p->next)
    {
        int j = p->id;  // 邻接点编号
        if (!st[j])     // 若该点没访问过
            dfs(j);
    }
    
    cout << u << ' ';   // 退出递归时输出
    // 此时得到逆拓扑有序序列
}

int main()
{
    cin >> n >> m;
    while (m--)
    {
        int a, b;
        cin >> a >> b;
        add(a, b);
    }
    
    dfs(1);

    return 0;
}

Xnip2023-12-20_23-38-46.png

4.2深度优先遍历判断图中是否有环的算法如下:

  1. 选择一个起始节点,将其标记为"正在访问"状态。

  2. 检查当前节点的所有相邻节点:

    • 如果相邻节点为"未访问"状态,则递归地进行深度优先搜索这个节点

      • 如果在搜索过程中发现这个节点已经被标记为"正在访问",则说明存在环路,返回true

    • 如果相邻节点状态为"已访问",忽略该节点

  3. 所有相邻节点均处理完成后,将当前节点标记为"已访问"状态,并返回上层递归

  4. 如果整个图都搜索完,没有返回true,则说明图中不存在环路,返回false。

主要思路是:

  • 使用"未访问"、"正在访问"和"已访问"三种节点状态进行标记

  • 如果搜索某个节点时发现其状态为"正在访问",则说明从此节点开始一定存在一个环路

  • 整个深度优先搜索结束没有返回true,则该图不存在环路

通过遍历每个节点及其相邻节点,并检查其访问状态就可以判断是否存在环路。时间复杂度为O(V+E),空间复杂度为O(V)。

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 100010;

int n, m, q[N], top;
int st[N];  // 0表示没有遍历过，1表示在递归当中，2表示已经遍历完了

struct Node
{
    int id;
    Node* next;
    Node(int _id) : id(_id), next(NULL){}
} *head[N];

void add(int a, int b)
{
    Node* p = new Node(b);
    p->next = head[a];      // 头插法
    head[a] = p;
}

bool dfs(int u)     // 如果有环的话返回false
{
    st[u] = 1;      // 标记当前点在递归中
    
    for (Node* p = head[u]; p; p = p->next)
    {
        int j = p->id;
        if (!st[j])     // 如果没有搜过的话（0）就直接搜
        {
            if (!dfs(j)) return false;  // 如果搜的过程中出现了环，直接false
        }
        else if (st[j] == 1) return false;   // 否则如果发现这个点在递归当中，直接false
    }
    
    q[top ++] = u;
    
    st[u] = 2;      // 标记当前点已经遍历完了
    
    return true;
}

// 基于深搜的话要遍历所有点，因为这个图不一定是联通的
bool topsort()
{
    for (int i = 1; i <= n; i ++)
        if (!st[i] && !dfs(i)) // 如果没遍历的话就遍历它，如果发现有环的话直接false
            return false;
    return true;
}

int main()
{
    cin >> n >> m;
    while (m -- )
    {
        int a, b;
        cin >> a >> b;
        add(a, b);
    }
    
    if (topsort())
    {
        // 因为得到的是拓扑排序的逆序序列，所以要倒序输出
        for (int i = n - 1; i >= 0; i -- ) cout << q[i] << ' ';
        cout << endl;
    }
    else puts("-1");
    
    return 0;
}

以上内容来自【xjtu915 冲刺班】

xjtu915
关注
专栏目录
点云从入门到精通技术详解100篇-定子装配过程中基于深度学习的易变形材料的点云分割（下）
getusushu的博客
09-22 106
但算法在实际运行时间和算法复杂度上，由逊色于传统的算法，这是无法兼顾精度需求与效率的结果，同时该方法在对象复杂的点云上进行预处理，效果较差，这需要。法，进行适用于三维点云的 Transformer 网络改进。参数量情况下，论文提出的网络精度比 PointNet 高出 2%左右，而在与 DGCNN 的比较。二维的 Vision Transformer 网络中，提到使用图像切割的方法，得到不同区域的特。堆叠 Transformer 的注意力层数，我们可以获得更深层的予以信息，然而，当继续堆叠。
2024 AI 人工智能完整学习路线表
最新发布
AI天才研究院
09-14 1913
本阶段讲解，人工智能的应用，人工智能的工作流程、基本概念，人工智能的任务和本质，KNN最近邻算法。本阶段讲解，python基础语法，Numpy科学计算模块，Pandas数据分析模块，Matplotlib和Seaborn数据可视化模块。本阶段讲解，微积分基础，线性代数基础，多元函数微分学，线性代数高级，概率论，最优化。本阶段讲解，多元线性回归，梯度下降法，归一化，正则化，Lasso回归，Ridge回归，多项式回归。
2020.7.28暑期集训--拓步排序
qq_44797733的博客
07-29 266
拓步排序 相关概念 拓步排序：对一个有向无环图G进行拓扑排序，是将G中所有顶点排成 一个线性序列，使得图中任意丏对顶点u和v，若 边< u, v >∈E(G)，则u在线性序列中出现在v 之前。通常， 这样的线性序列称为满足拓扑次序的序列，简称拓扑序列。 如果图中存在环，则无法进行拓扑排序。 BFS的算法流程： (1) 在图中选择所有入度为零的顶点，加入队列。 (2) 从队列中取出一个点，删除该点及其所有出边(对应点的 入度-1)。 重复(1)...
拓扑排序（dfs用栈，bfs用队列）
weixin_42738495的博客
05-17 1966
现在你总共有 n 门课需要选，记为 0 到 n-1。 在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们: [0,1] 给定课程总量以及它们的先决条件，返回你为了学完所有课程所安排的学习顺序。 可能会有多个正确的顺序，你只要返回一种就可以了。如果不可能完成所有课程，返回一个空数组。 示例 1: 输入: 2, [[1,0]] 输出: [0,1] 解释: 总共有 2 门课程。要学习课程 1，你需要先完成课程 0。因此，正确的课程顺序为 [0,1] 。
拓扑排序+优先队列Labeling Balls
youngkl博客
08-20 851
poj 3687
拓扑排序与关键路径
热门推荐
HHHHHHep的博客
12-21 1万+
2-5      解析 ： ① a e b c d， ②a b c e d ,③a b e c d。 2-1 在AOE网中，什么是关键路径？ (1分) 最短回路最长回路从第一个事件到最后一个事件的最短路径从第一个事件到最后一个事件的最长路径 作者: DS课程组 单位: 浙江大学 2-2 在拓扑排序算法中用堆栈和用队列产
拓扑排序变形poj3687
龙崎的专栏
06-16 620
题意为拓扑排序，使得小的结点尽可能的排在前面： 如：5->6->1; 4->3->2   应让结点1尽量排在前面，再使2尽量排在前面... ...：5 6 1 4 3 2 若直接按结点从小到大拓扑排序，无法得到正解：4 3 2 5 6 1 反向拓扑排序，按结点从大到小的顺序这样能使结点小的尽可能的排在后面：2 3 4 1 6 5，那么反过来的5 6 1 4 3 2就是所求的拓扑序列，
关系动态推理网络: 一种新型的文件实现关系路由器模型以优化动态推理，降低计算成本
本文从路由器和样本两个方面对动态推理的关系进行我们设计了一种新型的路由器称为关系路由器的模型路由器之间的关系，为一个给定的样本。原则上，当前关系路由器通过图卷积聚合先前路由器的上下文特征，并
基于递归神经网络的变网格拓扑参数模型-机器学习方法用于结构裂纹识别的研究
阵列14（2022）100137基于递归神经网络的变网格拓扑参数Lars Grevea，*，Bram Pieter van de Wega，baVolkswagen AG，D-38436，Wolfsburg，Germanyb P.O. 特文特大学工程技术学院应用力学和数据分析Box 217，7500，...
数据结构与算法（Python版）——（7）系统性的介绍图，以及图的python代码实现
Ma Sizhou
05-08 1098
上一小节链接. 目录1、图graph的概念：1.1 术语表及定义：1.2 抽象数据类型：图2、图的python实现： 1、图graph的概念： 在这一章我们学习图。图是比我们上一章学习的树更普遍的结构，事实上我们可以认为树是一种特殊的图。图可以被用来表述世界上很多有趣的事情，包括道路系统，城市间航线，因特网的联接，甚至是你完成计算机科学学位所必修的课程顺序。接下来将看到一旦我们很好地表述了某个问题，我们可以使用标准的图算法来解决一些看起来非常困难的问题。 对人类来说，看懂路线图并了解不同地点之间的.
数据结构——串的定义与基本操作
ice's blog
09-17 6928
串的定义与基本原子操作
soj 1075 拓扑排序队列实现
liujc_的专栏
03-27 1000
就是soj 拓扑排序的模板题吧。然后我中午把用队列实现的拓扑排序的方法看了下。晚上就打算来练一下这种纯模板。 对于这实现的方法，我的理解就是存下每个节点的入度以及它指向的其他节点，由于指向多少个这个不太能确定所以用一个vector来存。然后将入度为零的节点取出来入队列，再将其所指向的节点之间的边都删掉（也就是将所指向的节点的入度减1）减掉之后如果这个点变为入度为0了，就可以将其入队了。。还有关于
拓扑排序队列处理
alusang的博客
02-04 488
#include #include #include #include using namespace std; const int maxn=1e6+10; int n,m,t; int G[1000][1000],id[1000],topo[1000]; void toposort() {     queue q;     int t=0;
图的应用之拓扑排序实现(辅助栈)
Tartarusi
01-26 2589
何为拓扑排序： 一般常见的图是有环的，不需要考虑顶点的先后顺序，而比如在一些工程中，工程的流程图就需要考虑顶点的先后顺序，比如B的前置条件是完成A，这就需要拓扑排序来判断图是否满足拓扑次序，并且能够形象的显示各个顶点的先后顺序。 拓扑排序有多种解，拓扑排序的解并不是唯一的，有些顶点的优先性是相同的。 通常我们把顶点表示活动，边表示活动的先后关系的有向图称为顶点活动网(Activity On
拓扑排序（Topological Sorting）
dbbaq24022的专栏
05-07 3652
一、什么是拓扑排序 在图论中，拓扑排序（Topological Sorting）是一个有向无环图（DAG, Directed Acyclic Graph）的所有顶点的线性序列。且该序列必须满足下面两个条件： 每个顶点出现且只出现一次。 若存在一条从顶点 A 到顶点 B 的路径，那么在序列中顶点 A 出现在顶点 B 的前面。 有向无环图（DAG）才有拓扑排序，...
拓扑排序以及队列栈的使用 (车站分级noip2013第四题）
pianoの安心小家
07-27 1372
问题描述 一条单向的铁路线上，依次有编号为 1, 2, …, n 的 n 个火车站。每个火车站都有一个级别，最低为 1 级。现有若干趟车次在这条线路上行驶，每一趟都满足如下要求：如果这趟车次停靠了火车站 x，则始发站、终点站之间所有级别大于等于火车站 x 的都必须停靠。（注意：起始站和终点站自然也算作事先已知需要停靠的站点）例如，下表是 5 趟车次的运行情况。其中，前 4 趟车次均满足要求，而第
拓扑排序中的栈存储结构
云计算?
01-17 424
近期看数据结构，看到拓扑排序中的栈存储数据结构，上面的栈使用数组进行存储，而非Stack定义，使用的非常妙，分享一下。 拓扑排序的主要思想：（1）选择一个入度为0的顶点并输出；（2）从网中删除此顶点及其所有边；（3）重复执行（1）（2）直到不存在入度为0的顶点；比如下面所示的图（采用邻接表表示）： 设置保存每个顶点的入度值的数组d，则d如下所示： 方式一：直接使用d数组作为栈，栈的使...
拓扑排序及算法实现
ShyTan的博客
04-21 1万+
一、拓扑排序概念 对一个有向无环图(Directed Acyclic Graph简称DAG)G进行拓扑排序，是将G中所有顶点排成一个线性序列，使得图中任意一对顶点u和v，若边<u,v>∈E(G)，则u在线性序列中出现在v之前。通常，这样的线性序列称为满足拓扑次序(Topological Order)的序列，简称拓扑序列。 简单的说，由某个集合上的一个偏序得到该集合上的一个全序，这个操作称之为拓扑排序。 二、理解 在一个有向图中，对所有的节点进行排序，要求没有一个节点指向它前面的节点。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值