【算法专题】关键路径及代码实现

最新推荐文章于 2024-06-28 00:01:03 发布
最新推荐文章于 2024-06-28 00:01:03 发布
阅读量1.4w 收藏 244
点赞数 49
分类专栏： 算法专题 文章标签： 关键路径 AOE网
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42638946/article/details/120154312
版权

关键路径

一. 问题描述

概念

  • 一项工程计划可以被看成一个有向图，图中的顶点表示事件，边代表活动，边上的权值代表完成这项活动需要的时间，这样的有向图称为AOE网。

  • 表示实际工程计划的AOE网应该是无环的，在正常情况下存在唯一的开始顶点（源点）和唯一的完成顶点（汇点）。

  • AOE网中的某些活动可以并行进行，完成工程的最短时间是从开始顶点到完成顶点的最长路径长度。路径长度最长的路径为关键路径。关键路径上所有活动都叫做关键活动。我们只有减少关键路径上活动用时才能加快工程的进度。

  • 我们的问题就是输出所有关键路径上的顶点。

一个例子

  • 如下图，求出下图的关键路径。

在这里插入图片描述

  • 如下图，青色代表的两条路径就是关键路径。只有减少这两条路径上活动用时才能加快工程进度。

  • 关键路径为：1->2->5->8->9和1->2->5->7->9。

在这里插入图片描述

二. 问题分析

  • AOE网的性质：

    • （1）只有在某顶点代表的事件发生后，从该顶点发出去的弧所代表的各项活动才能开始；

    • （2）只有进入某顶点的各条弧所代表的活动都已经结束，该顶点所代表的事件才能发生。

  • 求解关键路径需要求解出：事件（顶点）的最早、最迟发生时间；

  • 求解关键活动需要求解出：活动（边）的最早、最迟发生时间完成。

  • 使用数组ve、vl分别表示事件的最早、最晚发生时间；使用数组ee、el分别表示活动的最早、最晚发生时间。

  • 总体思路：首先求出原图的拓扑序列，然后根据拓扑序推出上述四个数组。

ve数组的求解：事件的最早发生时间

  • ve[start]=0：start为源点，在0时刻就可以开始。

  • 事件 v i v_i vi​ 的最早发生时间ve[i]是从开始顶点 v s t a r t v_{start} vstart​ 到顶点 v i v_i vi​ 的最长路径长度。

  • 按照拓扑序求解：假设在原图中存在一条边(ver, j)，边的权重为w[i]，则ve[j] = max(ve[j], ve[ver] + w[i])。

vl数组的求解：事件的最晚发生时间

  • vl[end]=ve[end]：end为汇点。

  • 事件 v i v_i vi​ 允许的最晚发生时间vl[i]是在保证完成顶点 v e n d v_{end} vend​ 在ve[end]时刻发生的前提下，事件 v i v_i vi​ 允许发生的最晚时间，它等于ve[end]减去 v i v_i vi​ 到 v e n d v_{end} vend​ 的最长路径长度。

  • 按照拓扑序的逆序求解，因此需要使用原图的反向图。假设在反向图中存在一条反向边(ver, j)，边的权重为w[i]，则vl[j] = min(vl[j], vl[ver] - w[i])。

根据上述求出的ve、vl数组，我们可以得出关键路径上的点，所有vl[i]-ve[i]==0的点是关键路径上的点，对于上面的例子，我们可以得到下表：

顶点ve[i]vl[i]vl[i]-ve[i]
1000
2660
3462
4583
5770
67103
716160
814140
918180

从起点做一遍dfs就可以求出关键路径上的点。

ee数组的求解：活动的最早发生时间

  • 在建图的时候，我们每次会在原图和反向图中分别加一条边，边的编号从0开始，因此0、1，2、3…等都是成对出现的，其中偶数编号的边在原图中，奇数编号的边在反向图中。我们求解原图中的关键边即可。

  • 在原图中根据拓扑序求解ee，如果存在一条(ver, j)的边，边的编号为i，则ee[i]=ve[ver]。

el数组的求解：活动的最晚发生时间

  • 需要在反向图中求解el数组，如果在反向图存在一条(ver, j)的边，边的编号为i，则el[i-1]=vl[ver]-w[i]。这里i-1是因为我们求解的是原图中的关键边。

根据上述求出的ee、el数组，我们可以得出关键路径上的边，所有el[i]-ee[i]==0的边是关键路径上的边，对于上面的例子，我们可以得到下表：

活动活动在原图中的编号iee[i]el[i]el[i]-ee[i]
a10000
a22022
a34033
a46660
a58462
a610583
a712770
a814770
a9167103
a101816160
a112014140

从起点做一遍dfs就可以求出关键路径上的边。

三. 代码实现

  • 这里使用问题描述的图进行测试，测试输入如下：
9 11
1 2 6
1 3 4
1 4 5
2 5 1
3 5 1
4 6 2
5 7 9
5 8 7
6 8 4
7 9 2
8 9 4

  • 第一行两个数n、m，代表图中的点数、边数；

  • 接下来的m行，每行有三个数a、b、c表示有一条从a指向b且权重为c的边。

  • 默认这里1号点为源点，n号点为汇点。

只求解关键路径

#include <iostream>
#include <cstring>
#include <vector>

using namespace std;

const int N = 1010, M = 100010;

int n, m;
int hs[N], ht[N], e[M], w[M], ne[M], idx;  // 顶点表示事件，边表示活动

int ve[N], vl[N];  // 事件允许的最早发生时间, 事件允许的最晚发生时间
// int ee[M], el[M];  // 活动的最早发生时间, 活动的最晚发生时间

int d[N];  // 每个点的入度
int q[N];  // 拓扑排序数组

vector<int> path;
vector<vector<int>> res;

void add(int h[], int a, int b, int c) {
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}

void topsort() {

    int hh = 0, tt = 0;
    q[0] = 1;
    while (hh <= tt) {
        int t = q[hh++];
        for (int i = hs[t]; ~i; i = ne[i]) {
            int j = e[i];
            if (--d[j] == 0)
                q[++tt] = j;
        }
    }
}

void critical_path() {

    topsort();

    // 求解事件允许的最早发生时间
    ve[1] = 0;
    for (int k = 0; k < n; k++) {
        int ver = q[k];
        for (int i = hs[ver]; i != -1; i = ne[i]) {
            int j = e[i];
            ve[j] = max(ve[j], ve[ver] + w[i]);
        }
    }

    // 求解事件允许的最晚发生时间
    memset(vl, 0x3f, sizeof vl);
    vl[n] = ve[n];
    for (int k = n - 1; k >= 0; k--) {
        int ver = q[k];
        for (int i = ht[ver]; i != -1; i = ne[i]) {
            int j = e[i];
            vl[j] = min(vl[j], vl[ver] - w[i]);
        }
    }
}

void dfs(int u) {
    
    path.push_back(u);
    
    if (hs[u] == -1) {
        res.push_back(path);
    }
    
    for (int i = hs[u]; ~i; i = ne[i]) {
        int j = e[i];
        if (vl[j] - ve[j] == 0)
            dfs(j);
    }
    
    path.pop_back();
}

int main() {

    cin >> n >> m;
    memset(hs, -1, sizeof hs);
    memset(ht, -1, sizeof ht);
    for (int i = 0; i < m; i++) {
        int a, b, c;
        cin >> a >> b >> c;
        add(hs, a, b, c);
        add(ht, b, a, c);
        d[b]++;
    }

    // 输入满足1号点是源点，n号点是汇点
    critical_path();
    
    dfs(1);
    
    for (auto &t : res) {
        for (int i = 0; i < t.size(); i++)
            cout << t[i] << ' ';
        cout << endl;
    }

    return 0;
}

结果如下（关键路径经过的点）：

1 2 5 8 9 
1 2 5 7 9

求解关键路径 和 关键活动

#include <iostream>
#include <cstring>
#include <vector>

using namespace std;

const int N = 1010, M = 100010;

int n, m;  // 顶点数、边数
int hs[N], ht[N], e[M], w[M], ne[M], idx;  // 顶点表示事件，边表示活动

int ve[N], vl[N];  // 事件允许的最早发生时间, 事件允许的最晚发生时间
int ee[M], el[M];  // 活动的最早发生时间, 活动的最晚发生时间

int d[N];  // 每个点的入度
int q[N];  // 拓扑排序数组

// 存储关键路径上的点
vector<int> path;
vector<vector<int>> res;
// 存储关键路径上的边
vector<int> edge;
vector<vector<int>> edges;

void add(int h[], int a, int b, int c) {
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}

void topsort() {

    int hh = 0, tt = 0;
    q[0] = 1;
    while (hh <= tt) {
        int t = q[hh++];
        for (int i = hs[t]; ~i; i = ne[i]) {
            int j = e[i];
            if (--d[j] == 0)
                q[++tt] = j;
        }
    }
}

void critical_path() {

    topsort();

    // 求解事件允许的最早发生时间
    ve[1] = 0;
    for (int k = 0; k < n; k++) {
        int ver = q[k];
        for (int i = hs[ver]; i != -1; i = ne[i]) {
            int j = e[i];
            ve[j] = max(ve[j], ve[ver] + w[i]);
        }
    }

    // 求解事件允许的最晚发生时间
    memset(vl, 0x3f, sizeof vl);
    vl[n] = ve[n];
    for (int k = n - 1; k >= 0; k--) {
        int ver = q[k];
        for (int i = ht[ver]; i != -1; i = ne[i]) {
            int j = e[i];
            vl[j] = min(vl[j], vl[ver] - w[i]);
        }
    }
    
    // 求解活动的最早发生时间
    for (int k = 0; k < n; k++) {
        int ver = q[k];
        for (int i = hs[ver]; i != -1; i = ne[i]) {  // (ver, j), 正向边为i
            ee[i] = ve[ver];
        }
    }
    
    // 求解活动的最晚发生时间
    for (int k = n - 1; k != -1; k--) {
        int ver = q[k];
        for (int i = ht[ver]; i != -1; i = ne[i]) {  // (ver, j), 反向边为i
            el[i - 1] = vl[ver] - w[i];  // i-1是原图中边的编号
        }
    }
}

void dfs_v(int u) {
    
    path.push_back(u);
    
    if (hs[u] == -1) {
        res.push_back(path);
    }
    
    for (int i = hs[u]; ~i; i = ne[i]) {
        int j = e[i];
        if (vl[j] - ve[j] == 0)
            dfs_v(j);
    }
    
    path.pop_back();
}

void dfs_e(int u) {
    
    if (hs[u] == -1) {
        edges.push_back(edge);
    }
    
    for (int i = hs[u]; ~i; i = ne[i]) {
        int j = e[i];
        if (el[i] - ee[i] == 0) {
            edge.push_back(w[i]);
            dfs_e(j);
            edge.pop_back();
        }
    }
}

void out() {
    
    cout << endl;
    
    // 输出上述分析中的ve、vl数组
    cout << "ve :      ";
    for (int i = 1; i <= n; i++) cout << ve[i] << ' ';
    cout << endl;
    
    cout << "vl :      ";
    for (int i = 1; i <= n; i++) cout << vl[i] << ' ';
    cout << endl;
    
    cout << "vl - ve : ";
    for (int i = 1; i <= n; i++) cout << vl[i] - ve[i] << ' ';
    cout << endl;
    
    cout << "-------------------------------" << endl;
    // 输出上述分析中的ee、el数组
    cout << "ee :      ";
    for (int i = 0; i < idx; i += 2) cout << ee[i] << ' ';
    cout << endl;
    
    cout << "el :      ";
    for (int i = 0; i < idx; i += 2) cout << el[i] << ' ';
    cout << endl;
    
    cout << "el - ee : ";
    for (int i = 0; i < idx; i += 2) cout << el[i] - ee[i] << ' ';
    cout << endl;
}

int main() {

    cin >> n >> m;
    memset(hs, -1, sizeof hs);
    memset(ht, -1, sizeof ht);
    for (int i = 0; i < m; i++) {
        int a, b, c;
        cin >> a >> b >> c;
        add(hs, a, b, c);
        add(ht, b, a, c);
        d[b]++;
    }

    // 输入满足1号点是源点，n号点是汇点
    critical_path();
    
    
    dfs_v(1);  // 求解关键路径上的点
    dfs_e(1);  // 求解关键路径上的边
    
    // 输出关键路径 以及关键路径上的权值
    int cnt = res.size();  // 一共cnt条关键路径
    for (int i = 0; i < cnt; i++) {
        // 先输出边的上权值
        auto cri_edge = edges[i];
        cout << "   ";
        for (auto t : cri_edge)
            cout << t << "    ";
        cout << endl;
        
        // 输出顶点
        auto cri_node = res[i];
        cout << cri_node[0];
        for (int i = 1; i < cri_node.size(); i++)
            cout << " -> " << cri_node[i];
        cout << endl;
    }
    
    // 输出上述分析的两个表
    out();

    return 0;
}

结果如下：

   6    1    7    4    
1 -> 2 -> 5 -> 8 -> 9
   6    1    9    2    
1 -> 2 -> 5 -> 7 -> 9

ve :      0 6 4 5 7 7 16 14 18 
vl :      0 6 6 8 7 10 16 14 18 
vl - ve : 0 0 2 3 0 3 0 0 0 
-------------------------------
ee :      0 0 0 6 4 5 7 7 7 16 14 
el :      0 2 3 6 6 8 7 7 10 16 14 
el - ee : 0 2 3 0 2 3 0 0 3 0 0

结果分析：

在这里插入图片描述

你好世界wxx
关注
专栏目录
关键路径 代码实现
qingshimingyue1992的专栏
12-16 788
template bool AdjGraph::ModifyTopSort(int VE[100],int SortArray1[100])//对图进行拓扑排序,获得各个顶点事件的最早发生时间,将序列存放在数组SortArray中 { int n=vertexNum; int indegree[100];//创建一个数组记录各个顶点的入度 int v; for(v=0;v { in
关键路径(完整实例及C语言完整代码实现)
热门推荐
记录博主学到的点滴
08-15 1万+
写在前面：博主是一位普普通通的19届二本大学生，平时最大的爱好就是听听歌，逛逛B站。博主很喜欢的一句话花开堪折直须折，莫待无花空折枝：博主的理解是头一次为人，就应该做自己想做的事，做自己不后悔的事，做自己以后不会留有遗憾的事，做自己觉得有意义的事，不浪费这大好的青春年华。博主写博客目的是记录所学到的知识并方便自己复习，在记录知识的同时获得部分浏览量，得到更多人的认可，满足小小的成就感，同时在写博客的途中结交更多志同道合的朋友，让自己在技术的路上并不孤单。 目录: 1. 2. 3.  &n.
Day_39关键路径
DARRENANJIAN的博客
05-29 3203
关键路径
关键路径代码实现
09-02
用c++实现的关键路径的代码。希望对大家有所帮助！
关键路径代码
05-01
自己初学数据结构写的，有关关键路径的代码，有什么不对的还望见谅
关键路径算法 具体代码实现
u010679895的专栏
07-19 1355
代码实现： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 Status TopologicalOrder(ALGraph G, Stack &T) {
【路径规划】基于蚁群算法求解各节点最短路径matlab代码.zip
12-24
【路径规划】基于蚁群算法求解各节点最短路径MATLAB代码是一个涉及计算机科学、优化算法和软件实现的专题。蚁群算法（Ant Colony Optimization, ACO）是一种仿生优化算法，它受到蚂蚁在寻找食物过程中通过释放信息...
天津大学计算机考研面试（复试）算法专题（很全面）
01-03
天津大学计算机考研面试（复试）中的算法专题是一个重要的知识领域，涵盖了广泛的算法理论与实践内容。在准备这个环节时，考生需要对算法有深入的理解和熟练的应用能力。以下是一些关键的算法知识点： 1. **排序...
数据结构与算法专业课程设计专题计划数学与计算机系信计本科.doc
11-21
7. **AOE网关键路径**：在给定的活动-on-event（AOE）网络中，找出关键路径及其长度，识别关键活动。 8. **二叉排序树**： - 输入数据序列生成二叉排序树。 - 中序遍历输出结果。 - 删除指定元素并进行中序遍历...
matlab优化算法：3专题 彻底精通免疫算法通过六个matlab建模案例.zip
05-26
MATLAB中实现这些机制的关键在于编写合适的算法代码，包括初始化种群、适应度函数设计、选择策略、变异和交叉操作等步骤。 案例一：单变量函数优化。这个简单的案例将展示如何使用免疫算法解决常见的单变量最优化...
关键路径的代码
01-07
对关键路径的描述利于关键路径输入这个工程的活动个数这个工程的化成图形的节点数
关键路径的算法设计与实现(C语言)
05-15
关键路径的算法设计与实现，c语言，可运行.....
关键路径图及算法题
11-09
关键路径图及算法题的ppt ，比较有效的 密码：hbsoft.net336*ABC 选择只读就可以看了
算法竞赛专题解析--搜索进阶(1)搜索基础1
08-04
《算法竞赛专题解析--搜索进阶(1)搜索基础1》 在算法竞赛的世界里，搜索是一种基础且重要的解决问题的方法，它源于“暴力法”思想，即通过穷举所有可能的解来找到正确答案。本篇文章主要探讨搜索的基础知识，包括...
关键路径C++代码实现
newbie的博客
11-22 648
图的应用----关键路径，C++易懂代码实现。欢迎仍有疑惑的小伙伴与我讨论哦~
关键路径——C语言（代码）
最新发布
2302_80790488的博客
06-28 552
然后我们要来计算事件的最早开始和最晚开始时间，首先要遍历每两个事件之间的活动，得到活动的最大值（计算最早开始时间，因为要考虑事件前驱的所有活动都完成）：
关键路径（代码讲解）- 数据结构和算法68
weixin_34344403的博客
06-27 180
关键路径（代码讲解） 让编程改变世界 Change the world by program 关键路径 etv(Earliest Time Of Vertex)：事件最早发生时间，就是顶点的最早发生时间； ltv(Latest Time Of Vertex)：事件最晚发生时间，就是每个顶点对应的事件最晚需要开始的时间，如果超出此时间将会延误整个工期。 ete(Earlie...
关键路径 完整代码+解析
m0_61628700的博客
06-03 1402
关键路径A.相关概念AOE网：边表示活动，顶点表示事件，边上权值表示活动持续时间。AOV网：顶点表示活动，弧表示活动间的优先关系。关键路径用AOE网，顶点表示活动，弧表示活动间的优先关系。入度：到达此顶点的路径条数。出度：从此顶点出去的路径条数。源点：入度为0，路径起始点。汇点：出度为0，路径终止点。拓扑序列：间有一条路径，则这条路径就是拓扑序列。拓扑排序：对有向图构造拓扑序列的过程。对AOV网拓扑排序的思路：1.找到入度为0的顶点输出；2.删去此顶点，及以改顶点为尾的弧；3.重复1，2两步，直到没有入度为
关键路径算法c++实现
05-19
关键路径算法，又称关键路径分析，是一种用于确定项目中关键任务的方法。关键路径是指在项目完成时间不变的情况下，导致项目完成时间延长的任务序列。 以下是C++实现关键路径算法的代码： ```c++ #include <iostream> #include <vector> #include <queue> using namespace std; struct Edge { int to, weight; }; vector<int> topological_sort(vector<vector<Edge>>& graph) { vector<int> in_degree(graph.size(), 0); for (int i = 0; i < graph.size(); ++i) { for (auto& e : graph[i]) { in_degree[e.to]++; } } queue<int> q; for (int i = 0; i < in_degree.size(); ++i) { if (in_degree[i] == 0) { q.push(i); } } vector<int> result; while (!q.empty()) { int u = q.front(); q.pop(); result.push_back(u); for (auto& e : graph[u]) { in_degree[e.to]--; if (in_degree[e.to] == 0) { q.push(e.to); } } } return result; } void critical_path(vector<vector<Edge>>& graph) { vector<int> topo_order = topological_sort(graph); vector<int> earliest_time(graph.size(), 0); for (int u : topo_order) { for (auto& e : graph[u]) { earliest_time[e.to] = max(earliest_time[e.to], earliest_time[u] + e.weight); } } vector<int> latest_time(graph.size(), earliest_time.back()); for (int i = topo_order.size() - 1; i >= 0; --i) { int u = topo_order[i]; for (auto& e : graph[u]) { latest_time[u] = min(latest_time[u], latest_time[e.to] - e.weight); } } cout << "Critical path:" << endl; for (int u = 0; u < graph.size(); ++u) { for (auto& e : graph[u]) { int task_time = earliest_time[u] + e.weight + latest_time[e.to] - earliest_time.back(); if (task_time == 0) { cout << u << " -> " << e.to << endl; } } } } int main() { // 举例：一个项目的任务时间如下所示 // (0) -> (1) -> (2) -> (3) -> (4) // 2 3 1 4 3 vector<vector<Edge>> graph(5); graph[0].push_back({1, 2}); graph[1].push_back({2, 3}); graph[2].push_back({3, 1}); graph[3].push_back({4, 4}); critical_path(graph); return 0; } ``` 输出： ``` Critical path: 0 -> 1 1 -> 2 2 -> 3 3 -> 4 ```
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值