BUCT数据结构——图（拓扑排序、关键路径）

最新推荐文章于 2024-07-17 12:13:29 发布
最新推荐文章于 2024-07-17 12:13:29 发布
阅读量1.1k 收藏 4
点赞数 3
分类专栏： 应试数据结构 文章标签： 数据结构 链表 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41729237/article/details/121778600
版权

文章目录


注：前面几个题基本上是最后一个题改过来的，如有错误，欢迎指正

问题 A: 邻接矩阵存储的图，节点的出度和入度计算(附加代码模式)

#include <iostream>
#include <cstdio>
using namespace std;

#define MAX_SIZE 100

struct Graph{
    int nodeNumber;
    int adjMatrix[MAX_SIZE][MAX_SIZE];
};

// 计算每个节点的出度和入度
void CalculateDegree(const Graph& g, int inDegree[], int outDegree[]){
    int n=g.nodeNumber;
    for( int i=0;i<n;i++){
        for( int j=0;j<n;j++){
            if(g.adjMatrix[i][j]==0) continue;
            inDegree[j]++;
            outDegree[i]++;
        }
    }
}

please comment the following code when you submit to OJ
int main(){
    // freopen("/config/workspace/answer/test.in","r",stdin);
    Graph g;
    cin >> g.nodeNumber;
    int inDegree[g.nodeNumber] = {0}, outDegree[g.nodeNumber] = {0};
    for(int i=0;i<g.nodeNumber;i++){
        for(int j=0;j<g.nodeNumber;j++){
            cin >> g.adjMatrix[i][j];
        }
    }
    CalculateDegree(g, inDegree, outDegree);
    for(int i=0;i<g.nodeNumber;i++){
        cout << inDegree[i] << " " << outDegree[i] << endl;
    }
    return 0;
}

问题 B: 算法7-12：有向无环图的拓扑排序

#include <bits/stdc++.h>
using namespace std;
const int N = 1100;
struct p
{
    int from, to, val;
} edge[N];
int w[N][N];
vector<int> ans;
int e[N], l[N], ve[N], vl[N];
int top_sort(int n)
{
    int indeg[N] = {};
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            if (w[i][j] == 0)
                continue;
            indeg[j]++;
        }
    }
    stack<int> Point;
    for (int j = 0; j < n; j++)
    {
        if (indeg[j] == 0)
        {
            Point.push(j);
        }
    }
    while (!Point.empty())
    {
        int ne = Point.top();
        Point.pop();
        ans.push_back(ne);
        for (int j = 0; j < n; j++)
        {
            if (w[ne][j] != 0)
                indeg[j]--;
            else
                continue;
            if (indeg[j] == 0)
            {
                Point.push(j);
            }
        }
    }
    if (ans.size() != n)
        return -1;
    return 0;
}

int main()
{
    int n;
    cin >> n;
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            cin >> w[i][j];
        }
    }
    if (top_sort(n) == -1)
    {
        cout << "ERROR" << endl;
    }
    else
    {
        for (int i = 0; i < ans.size(); i++)
        {
            cout << ans[i] << " ";
        }
    }

    return 0;
}

问题 C: 有向图是否存在环？

#include <bits/stdc++.h>
using namespace std;
const int N = 1100;
struct p
{
    int from, to, val;
} edge[N];
int w[N][N];
vector<int> ans;
int e[N], l[N], ve[N], vl[N];
int top_sort(int n)
{
    int indeg[N] = {};
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            if (w[i][j] == 0)
                continue;
            indeg[j]++;
        }
    }
    stack<int> Point;
    for (int j = 1; j <= n; j++)
    {
        if (indeg[j] == 0)
        {
            Point.push(j);
        }
    }
    while (!Point.empty())
    {
        int ne = Point.top();
        Point.pop();
        ans.push_back(ne);
        for (int j = 1; j <= n; j++)
        {
            if (w[ne][j] != 0)
                indeg[j]--;
            else
                continue;
            if (indeg[j] == 0)
            {
                Point.push(j);
            }
        }
    }
    if (ans.size() != n)
        return -1;
    return 0;
}

int main()
{
    int n, m;
    while (cin >> n >> m)
    {
        if (n == 0 && m == 0)
            break;
        memset(w, 0, sizeof(w));
        ans.clear();
        for (int i = 0; i < m; i++)
        {
            int a, b;
            cin >> a >> b;
            w[a][b] = 1;
        }
        if (top_sort(n) == -1)
        {
            cout << "YES" << endl;
        }
        else
        {
            cout << "NO" << endl;
        }
    }

    return 0;
}

问题 D: 图-节点的最早发生时间

#include <bits/stdc++.h>
using namespace std;
const int N = 110;
struct p
{
    int from, to, val;
} edge[N];
int w[N][N];
vector<int> ans;
int e[N], l[N], ve[N], vl[N];
int top_sort(int n)
{
    int indeg[N] = {};
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            if (w[i][j] == 0)
                continue;
            indeg[j]++;
        }
    }
    stack<int> Point;
    for (int j = 0; j < n; j++)
    {
        if (indeg[j] == 0)
        {
            Point.push(j);
        }
    }
    while (!Point.empty())
    {
        int ne = Point.top();
        Point.pop();
        ans.push_back(ne);
        for (int j = 0; j < n; j++)
        {
            if (w[ne][j] != 0)
                indeg[j]--;
            else
                continue;
            if (indeg[j] == 0)
            {
                Point.push(j);
            }
        }
    }
    if (ans.size() != n)
        return -1;
    return 0;
}

void cal(int n)
{
    for (int i = 0; i < ans.size(); i++)
    {
        int now = ans[i];
        for (int j = 0; j < n; j++)
        {

            if (w[now][j] == 0)
                continue;
            ve[j] = max(ve[now] + w[now][j], ve[j]);
        }
    }
    for (int i = 0; i < ans.size(); i++)
    {
        vl[i] = ve[ans[ans.size() - 1]];
    }
    for (int i = ans.size() - 1; i >= 0; i--)
    {
        int now = ans[i];
        for (int j = 0; j < n; j++)
        {
            if (w[now][j] == 0)
                continue;
            vl[now] = min(vl[j] - w[now][j], vl[now]);
        }
    }
    return;
}
int main()
{
    int n, m;
    cin >> n >> m;
    for (int i = 0; i < m; i++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        w[a][b] = c;
        edge[i].from = a;
        edge[i].to = b;
        edge[i].val = c;
    }
    top_sort(n);
    cal(n);
    for (int i = 0; i < n; i++)
    {
        cout << ve[i] << endl;
    }
    return 0;
}

问题 E: 图-节点的最迟发生时间

#include <bits/stdc++.h>
using namespace std;
const int N = 110;
struct p
{
    int from, to, val;
} edge[N];
int w[N][N];
vector<int> ans;
int e[N], l[N], ve[N], vl[N];
int top_sort(int n)
{
    int indeg[N] = {};
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            if (w[i][j] == 0)
                continue;
            indeg[j]++;
        }
    }
    stack<int> Point;
    for (int j = 0; j < n; j++)
    {
        if (indeg[j] == 0)
        {
            Point.push(j);
        }
    }
    while (!Point.empty())
    {
        int ne = Point.top();
        Point.pop();
        ans.push_back(ne);
        for (int j = 0; j < n; j++)
        {
            if (w[ne][j] != 0)
                indeg[j]--;
            else
                continue;
            if (indeg[j] == 0)
            {
                Point.push(j);
            }
        }
    }
    if (ans.size() != n)
        return -1;
    return 0;
}

void cal(int n)
{
    for (int i = 0; i < ans.size(); i++)
    {
        int now = ans[i];
        for (int j = 0; j < n; j++)
        {

            if (w[now][j] == 0)
                continue;
            ve[j] = max(ve[now] + w[now][j], ve[j]);
        }
    }
    for (int i = 0; i < ans.size(); i++)
    {
        vl[i] = ve[ans[ans.size() - 1]];
    }
    for (int i = ans.size() - 1; i >= 0; i--)
    {
        int now = ans[i];
        for (int j = 0; j < n; j++)
        {
            if (w[now][j] == 0)
                continue;
            vl[now] = min(vl[j] - w[now][j], vl[now]);
        }
    }
    return;
}
int main()
{
    int n, m;
    cin >> n >> m;
    for (int i = 0; i < m; i++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        w[a][b] = c;
        edge[i].from = a;
        edge[i].to = b;
        edge[i].val = c;
    }
    top_sort(n);
    cal(n);
    for (int i = 0; i < n; i++)
    {
        cout << vl[i] << endl;
    }
    return 0;
}

问题 F: 图-图的关键路径

#include <bits/stdc++.h>
using namespace std;
const int N = 110;
struct p
{
    int from, to, val;
} edge[N];
int w[N][N];
vector<int> ans;
int e[N], l[N], ve[N], vl[N];
int top_sort(int n)
{
    int indeg[N] = {};
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            if (w[i][j] == 0)
                continue;
            indeg[j]++;
        }
    }
    stack<int> Point;
    for (int j = 0; j < n; j++)
    {
        if (indeg[j] == 0)
        {
            Point.push(j);
        }
    }
    while (!Point.empty())
    {
        int ne = Point.top();
        Point.pop();
        ans.push_back(ne);
        for (int j = 0; j < n; j++)
        {
            if (w[ne][j] != 0)
                indeg[j]--;
            else
                continue;
            if (indeg[j] == 0)
            {
                Point.push(j);
            }
        }
    }
    if (ans.size() != n)
        return -1;
    return 0;
}

void cal(int n)
{
    for (int i = 0; i < ans.size(); i++)
    {
        int now = ans[i];
        for (int j = 0; j < n; j++)
        {

            if (w[now][j] == 0)
                continue;
            ve[j] = max(ve[now] + w[now][j], ve[j]);
        }
    }
    for (int i = 0; i < ans.size(); i++)
    {
        vl[i] = ve[ans[ans.size() - 1]];
    }
    for (int i = ans.size() - 1; i >= 0; i--)
    {
        int now = ans[i];
        for (int j = 0; j < n; j++)
        {
            if (w[now][j] == 0)
                continue;
            vl[now] = min(vl[j] - w[now][j], vl[now]);
        }
    }
    return;
}
int main()
{
    int n, m;
    cin >> n >> m;
    for (int i = 0; i < m; i++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        w[a][b] = c;
        edge[i].from = a;
        edge[i].to = b;
        edge[i].val = c;
    }
    top_sort(n);
    cal(n);
    for (int i = 0; i < m; i++)
    {
        e[i] = ve[edge[i].from];
        l[i] = vl[edge[i].to] - w[edge[i].from][edge[i].to];
        if (e[i] == l[i])
        {
            printf("%d-->%d:%d\n", edge[i].from, edge[i].to, e[i]);
        }
    }
    return 0;
}
_zpf
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构，链表基本操作
nankeyimeng的博客
03-28 2235
链表是数据结构中一种最基本的数据结构，它是用链式存储结构实现的线性表。它较顺序表而言在插入和删除时不必移动其后的元素。现在给你一些整数，然后会频繁地插入和删除其中的某些元素，会在其中某些时候让你查找某个元素或者输出当前链表中所有的元素。 下面给你基本的算法描述： 图1：链表类型的定义以及获得链表元素的算法描述 图2：链表的插入算法描述 图3：链表的删
严蔚敏版数据结构课本代码最最最完整版
10-22
严蔚敏版数据结构最最最完整版课本代码，懒得一篇一篇的传，有需要的自己下。（这是第二章的一个）
BUCTOJ题目部分源码（仅供学习和参考）
12-30
BUCTOJ部分试题的源码，包括有大概200多道题目，仅供学习和参考，当然其他OJ系统也会有类似的题目，也可以进行学习可参考，代码部分仅提供参考。
BUCT数据结构——图
qq_41729237的博客
11-28 648
文章目录问题 A: 将邻接矩阵存储的图转换为邻接表存储的图问题 B: 邻接表存储的图转化为邻接矩阵存储的图问题 C: 邻接矩阵存储图的DFS问题 D: 邻接矩阵存储图的DFS-非递归算法问题 E: 邻接矩阵存储图的BFS问题 F: 案例6-1.2：邻接表存储图的广度优先遍历问题 G: 邻接矩阵存储图的DFS完成序求解问题 H: 算法7-7,7-8：无向图的连通分量和生成树 问题 A: 将邻接矩阵存储的图转换为邻接表存储的图 #include<bits/stdc++.h> using namesp
buct数据结构——排序
qq_41729237的博客
12-23 1266
文章目录问题 A: 大顶堆还是小顶堆？问题 E: 算法10-6~10-8：快速排序问题 F: 有序归并问题 G: 算法10-1：直接插入排序问题 J: 基础实验7-2.2：插入排序还是堆排序问题 K: 案例7-1.2 插入排序还是归并排序 注：BCDHILM略 问题 A: 大顶堆还是小顶堆？ #include<bits/stdc++.h> using namespace std; typedef long long ll; const int N=100100; int w[N]; int n
buct数据结构——图算法（最短路、最小生成树）
qq_41729237的博客
12-01 866
北京化工大学数据结构作业答案
buct数据结构——平衡树和hash表
qq_41729237的博客
12-19 908
文章目录问题 A: 案例4-1.3：平衡二叉树的根问题 B: 二叉排序树 - 文本输出问题 C: 销售排行榜问题 D: 算法9-2：有序表的折半查找问题 E: Hash表-线性探测法解决冲突问题 F: 二叉排序树-平衡因子 问题 A: 案例4-1.3：平衡二叉树的根 #include<bits/stdc++.h> using namespace std; typedef unsigned long long ull; typedef long long ll; struct node { in
buct寒假集训——可持久化数据结构
qq_41729237的博客
02-10 359
文章目录超级马里奥 超级马里奥 hdu4417 正解是用可持久化线段树，时间复杂度 nlogn 但是这题的数据好像比较弱，用莫队 nsqrt(n)logn也能过。 莫队： #include <bits/stdc++.h> #include<ext/pb_ds/tree_policy.hpp> #include<ext/pb_ds/assoc_container.hpp> using namespace std; using namespace __gnu_pbds; ty
【BUCT数据结构类库】7.3--程序题--动态查找——二叉排序树实现
qq_49860380的博客
01-01 179
#include<iostream> using namespace std; //二叉排序树 typedef struct Node { int key; Node *left; Node *right; }*Tree; Tree insert(Tree root, int key) { if (root == NULL) { root = new Node; root->key = key; .
【BUCT数据结构类库】6.3--程序题--图的拓扑排序算法实现
qq_49860380的博客
12-31 136
#include<iostream> #include<vector> #include<algorithm> #define inf 0x3f3f3f3f using namespace std; //图的拓扑排序算法 //邻接矩阵法 typedef struct Mgraph{ int Vex[100];//顶点数组 int Edge[100][100];//边数组 int vexnum,edgenum;//图的顶点数和边数 }Mgrap.
buct_java实验
02-06
或者使用ArrayList和HashMap等集合类，介绍数据结构和算法；甚至会包含多线程编程，以理解并发和同步的概念。 【buct】（北京化工大学）是中国知名的高等学府，其计算机科学教育在业界有着良好的声誉。这个Java实验...
BUCTWXServicesFront:BUCT轻触 小程序前端项目
05-04
BUCT轻触 小程序前端代码 全局主题适配指南 1. 关于全局主题适配 全局主题适配部分主要包括各个页面的顶栏部分的背景颜色和文字颜色，以及页面中与顶栏保持同步颜色的区域。 2. JS文件适配 在每一个页面的JS文件中的...
BUCT数字图像处理上机考试训练.pdf
12-12
3. **结构图片截图**：可能是程序运行过程中的中间结果或最终结果的展示，用于证明代码的正确性。 4. **其他图片文件**：可能包括原始图像、处理后的图像或其他辅助材料，以便于理解处理过程。 考试规定在指定的...
【Java--数据结构】二叉树
2301_80898480的博客
07-16 1061
如有错误，欢迎指出~
数据结构第32节 无锁编程
最新发布
hummhumm的专栏
07-17 839
在Java中，无锁编程是一种在多线程环境下避免使用传统锁机制（如关键字或）的技术。这种技术可以提高程序的并发性能，尤其是在高并发场景下，因为它减少了锁的竞争和上下文切换的开销。
常见排序算法总结
mydaily_的博客
07-16 827
大概是因为插入排序没预处理，极端情况可能让一个很小很右的数一直比比比比比，比到最开头，浪费比较次数。某种情况比计数排序好，因为数字，如果按照普通十进制理解，则只需准备10个不同数字的桶就好了！整体的quickSort函数swap后，再进行partition，划分三部分后，所以这种不基于比较的算法应用范围很局限，大部分情况下，不如之前的所有比较算法！前提得知道空间范围，比如人的年龄，正数[0-200]，否则内存爆炸！间隔分组，且分组间隔依次减半，每次分组后，每个组内排序都是插入排序。
【数据结构】栈和队列
奋斗的小羊的博客
07-12 1892
栈超超超详解
数据结构(5.1)——树的性质
m0_65240792的博客
07-16 236
1%29%5D。
python buctoj 列表数据清理
05-18
对于列表数据清理，可以使用Python的列表推导式。列表推导式是一种简洁的语法，可以根据已有列表中的元素生成新的列表。 以下是一个简单的示例，演示如何使用列表推导式清理列表数据： ```python # 原始数据列表 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值