AOE网与关键路径、关键路径算法

最新推荐文章于 2022-10-07 08:39:08 发布
最新推荐文章于 2022-10-07 08:39:08 发布
阅读量2.3k 收藏 12
点赞数 1
分类专栏： 基础算法 数据结构概念相关 C语言相关 文章标签： 算法 c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42464569/article/details/109784353
版权

AOE网与关键路径

在一个表示工程的带权有向图中，用顶点表示事件，用有向边表示活动，边上的权值表示活动持续的时间，称这样的有向图为边表示活动的网，简称 AOE网(activity on edge network)。AOE网中没有入边的顶点称为源点，没有出边的顶点称为终点。AOE网具有以下两个性质：

  1. 只有在进入某顶点的各种活动都已经结束，该顶点表示的事件才能发生。
  2. 只有在某顶点所代表的事件发生后，从该顶点出发的活动才能开始。

如果用AOE网络来表示一项工程，那么，仅仅考虑各个活动之间的优先关系还不够，更多的是关心整个工程完成的最短时间是多少；那些活动延期将会影响整个工程的进度，而加速这些活动是否会提高整个工程的效率。

由于AOE网中的某些活动能够同时进行，故完成整个工程所必须花费的时间应该为始点到终点的最大路径长度（这里的路径长度是指该路径上的各个活动所持续的时间之和）。具有最大路径长度的路径称为关键路径，关键路径上的活动称为关键活动。关键路径长度是整个工程所需的最短工期。也就是说，要缩短整个工期，必须加快关键活动的进度。

关键路径算法

想要找到关键路径，需要计算四组数据，①事件的最早发生时间，②事件的最晚发生时间，③活动 a i a_i ai​的最早开始时间，④活动 a i a_i ai​的最晚结束时间。当存在 a i 的 最 在 开 始 时 间 = a i 最 晚 结 束 时 间 a_i的最在开始时间 = a_i最晚结束时间 ai​的最在开始时间=ai​最晚结束时间 时， a i a_i ai​就包含在关键路径里面。

事件最早发生时间 ve[k]

ve[k] 是指源点到顶点 v k v_k vk​ 的最大路径长度，这和长度决定了所有顶点从 v k v_k vk​ 出发的活动可以开始的最早时间。具AOE网的性质，只有进入 v k v_k vk​ 的所有活动 < v j , v k > <v_j, v_k> <vj​,vk​> 都结束时， v k v_k vk​ 代表的事件才能发生，而活动 < v j , v k > <v_j, v_k> <vj​,vk​> 的最早结束时间为 v e [ j ] + l e n < v j , v k > ve[j] + len<v_j, v_k> ve[j]+len<vj​,vk​>。所计算的最早发生时间的方法如下：

{ v e [ 0 ] = 0 v e [ k ] = m a x { v e [ j ] + l e n < v j , v k > } \begin{cases}ve[0]=0\\ve[k] = max\{ve[j] + len<v_j,v_k>\}\end{cases} {ve[0]=0ve[k]=max{ve[j]+len<vj​,vk​>}​

也就是计算从源点到这个顶点的最长路径，跟最短路径算法思路一样。

局部代码：

// 事件最早发生时间
int* ve = utils_createArr(n,0);
// 把源点入队列
queue_push(v_queue, createSNode(0));
while(queue_getLen(v_queue))
{
    v = queue_pop(v_queue)->value;
    for(int i = 0; i < n; i ++)
    {
        if(g[v][i] != -1)
        {
            queue_push(v_queue, createSNode(i));
            // 当存在比现存时间更晚时，替换
            if(ve[v] + g[v][i] > ve[i] )
            {
                ve[i] = ve[v] + g[v][i];
            }
        }
    }
}

事件的最迟发生时间 vl[k]

vl[k] 是指在不推迟整个工期的前提下，事件 v k v_k vk​ 允许的最晚发生时间。有向边 < v k , v j > <v_k,v_j> <vk​,vj​> 代表从 v k v_k vk​ 出发的活动，为了不拖延整个工期， v k v_k vk​ 发生的最迟事件必须保证不推迟从事件 v k v_k vk​ 出发的活动 < v k , v j > <v_k, v_j> <vk​,vj​> 的终点 v j v_j vj​ 的最迟时间 vl [ j ] 。vl [ k ] 的计算方法如下：

{ v l [ n − 1 ] = v e [ n − 1 ] v k [ k ] = m i n { v l [ j ] − l e n < v k , v j > } \begin{cases}vl[n-1]=ve[n-1]\\vk[k]=min\{vl[j]-len<v_k,v_j>\}\end{cases} {vl[n−1]=ve[n−1]vk[k]=min{vl[j]−len<vk​,vj​>}​

也就是 当 前 顶 点 的 最 迟 发 生 时 间 = 终 点 的 最 早 发 生 时 间 − 当 前 顶 点 到 终 点 的 最 长 路 径 当前顶点的最迟发生时间=终点的最早发生时间-当前顶点到终点的最长路径 当前顶点的最迟发生时间=终点的最早发生时间−当前顶点到终点的最长路径

局部代码：

// 事件最迟发生的时间
// 把初值赋为最大的时间，方便比较
int* vl = utils_createArr(n, ve[v]);
// 终点的最早结束时间等于最迟发生时间
vl[v] = ve[v];

// 把终点入队列，经过 上面运算，v指向AOE网终点
queue_push(v_queue, createSNode(v));
while(queue_getLen(v_queue))
{
    v = queue_pop(v_queue)->value;
    for(int i = 0; i < n; i ++)
    {
        if(g[i][v] != -1)
        {
            queue_push(v_queue, createSNode(i));
            // 当存在比现存时间更早时，替换
            if(vl[v] - g[i][v] < vl[i])
            {
                vl[i] = vl[v] - g[i][v];
            }
        }
    }
}

活动 a i a_i ai​ 的最早开始时间 ee[i]

若活动 a i a_i ai​ 由有向边 < v k , v j > <v_k, v_j> <vk​,vj​> 表示，根据AOE网的性质，只有事件 v k v_k vk​ 发生了，活动 a i a_i ai​ 才能开始。也就是说，活动 a i a_i ai​ 的最早开始时间等于事件 v k v_k vk​ 的最早发生事件。因此有：

e e [ i ] = v e [ k ] ee[i] = ve[k] ee[i]=ve[k]

局部代码：

/*
活动 ai 最早发生时间，i为从开始结点算起
从编号较低的结点到编号较高的结点
从指向编号较低的结点到指向编号较高的结点
*/
int* ee = utils_createArr(es, 0);
int* v_flag = utils_createArr(n, 1);
int ee_i = 0;

queue_push(v_queue, createSNode(0));
while(queue_getLen(v_queue))
{
    v = queue_pop(v_queue)->value;
    for(int i = 0; i < n; i ++)
    {
        if(g[v][i] != -1)
        {
            ee[ee_i++] = ve[v];
            if(v_flag[i])
            {
                queue_push(v_queue, createSNode(i));
                v_flag[i] = 0;
            }
        }
    }
}

活动 a i a_i ai​ 的最晚开始时间 el[i]

el [ i ] 是指在不推迟整个工期的前提下，活动 a i a_i ai​ 必须开始的最晚时间。若 a i a_i ai​ 由有向边 < v k , v j > <v_k, v_j> <vk​,vj​> 表示，则 a i a_i ai​ 的最晚开始时间要保证事件 v j v_j vj​ 的最迟延后时间不能后拖。因此有：

e l [ i ] = v l [ j ] − l e n < v k , v j > el[i] = vl[j] - len<v_k, v_j> el[i]=vl[j]−len<vk​,vj​>

局部代码：

/*
活动 ai 最迟发生时间
*/
int* el = utils_createArr(es, 0);
int el_i = 0;

v_flag = utils_createArr(n, 1);
queue_push(v_queue, createSNode(0));

while(queue_getLen(v_queue))
{
    v = queue_pop(v_queue)->value;
    for(int i = 0; i < n; i ++)
    {
        if(g[v][i] != -1)
        {
            el[el_i++] = vl[i] - g[v][i];
            if(v_flag[i])
            {
                queue_push(v_queue, createSNode(i));
                v_flag[i] = 0;
            }
        }
    }

}

完整代码实现和测试结果

完整代码：

// 关键路径
/*
g：邻接矩阵
n：顶点个数
es：边的个数

return：返回关键路径邻接矩阵
*/
int** graph_criticalPath(int** g, int n, int es)
{

    // 队列
    Queue* v_queue = createQueue();
    // 用来记录顶点下标的变量
    int v;

    // 事件最早发生时间
    int* ve = utils_createArr(n,0);
    // 把源点入队列
    queue_push(v_queue, createSNode(0));
    while(queue_getLen(v_queue))
    {
        v = queue_pop(v_queue)->value;
        for(int i = 0; i < n; i ++)
        {
            if(g[v][i] != -1)
            {
                queue_push(v_queue, createSNode(i));
                // 当存在比现存时间更晚时，替换
                if(ve[v] + g[v][i] > ve[i] )
                {
                    ve[i] = ve[v] + g[v][i];
                }
            }
        }
    }

    // 事件最迟发生的时间
    // 把初值赋为最大的时间，方便比较
    int* vl = utils_createArr(n, ve[v]);
    // 终点的最早结束时间等于最迟发生时间
    vl[v] = ve[v];

    // 把终点入队列，经过 上面运算，v指向AOE网终点
    queue_push(v_queue, createSNode(v));
    while(queue_getLen(v_queue))
    {
        v = queue_pop(v_queue)->value;
        for(int i = 0; i < n; i ++)
        {
            if(g[i][v] != -1)
            {
                queue_push(v_queue, createSNode(i));
                // 当存在比现存时间更早时，替换
                if(vl[v] - g[i][v] < vl[i])
                {
                    vl[i] = vl[v] - g[i][v];
                }
            }
        }
    }

    /*
    活动 ai 最早发生时间，i为从开始结点算起
    从编号较低的结点到编号较高的结点
    从指向编号较低的结点到指向编号较高的结点
    */
    int* ee = utils_createArr(es, 0);
    int* v_flag = utils_createArr(n, 1);
    int ee_i = 0;

    queue_push(v_queue, createSNode(0));
    while(queue_getLen(v_queue))
    {
        v = queue_pop(v_queue)->value;
        for(int i = 0; i < n; i ++)
        {
            if(g[v][i] != -1)
            {
                ee[ee_i++] = ve[v];
                if(v_flag[i])
                {
                    queue_push(v_queue, createSNode(i));
                    v_flag[i] = 0;
                }
            }
        }
    }


    /*
    活动 ai 最迟发生时间
    */
    int* el = utils_createArr(es, 0);
    int el_i = 0;

    v_flag = utils_createArr(n, 1);
    queue_push(v_queue, createSNode(0));

    while(queue_getLen(v_queue))
    {
        v = queue_pop(v_queue)->value;
        for(int i = 0; i < n; i ++)
        {
            if(g[v][i] != -1)
            {
                el[el_i++] = vl[i] - g[v][i];
                if(v_flag[i])
                {
                    queue_push(v_queue, createSNode(i));
                    v_flag[i] = 0;
                }
            }
        }

    }

    // 创建一个没有边的邻接矩阵
    int** g_cp = utils_create2DArr(n,n,-1);
    // 记录已经计算边数，用来计算是否为关键路径
    int cp_i = 0;
    for(int i = 0; i < n; i ++)
    {
        for(int j = 0; j < n; j ++)
        {
            if(g[i][j] != -1)
            {
                if(el[cp_i] - ee[cp_i] == 0)
                {
                    // 当活动最早发生时间=最晚发生时间，此活动在关键路径上
                    g_cp[i][j] = g[i][j];
                }
                cp_i++;
            }
        }
    }

    return g_cp;
}

测试样例：
在这里插入图片描述

测试代码：

#define N 9
#define M 33

int main()
{
    // 边数组，i%3=0 表示起点；i%3=1 表示终点；i%3=2 表示权值
    int arr[M] = {0,1,6,0,2,4,0,3,5,1,4,1,2,4,1,3,5,2,4,6,9,4,7,7,5,7,4,6,8,2,7,8,4};
    int** g = graph_createArrInValue(N, -1);
    // 创建相关邻接矩阵
    graph_createAdjacencyMatrixByArrWithWeight(g,arr, M, 1);

    printf("原图邻接矩阵：\n");
    graph_print(g, N, "%3d ");

    int** g_cp = graph_criticalPath(g,N,M/3);
    printf("关键路径邻接矩阵：\n");
    graph_print(g_cp, N, "%3d ");
    return 0;
}

运行结果：

在这里插入图片描述

关键路径展示：
在这里插入图片描述

HMTT
关注
  • 1
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】AOE网与关键路径
l634007854的博客
12-04 475
快速求解方法： 数据结构—图，一分钟求解关键路径！
【笔记】AOE网与关键路径
热门推荐
time-space的博客
12-02 4万+
AOE网 关键路径 求关键路径的算法实现
AOE网 求关键路径（用邻接表实现）
西叶胡杨的博客
12-12 3781
概念 AOE网，即边表示活动的网，是一个带权的有向无环图，其中顶点表示事件（Event），每个事件表示在它之前的活动已经完成，在它之后的活动可以开始，弧表示活动，权表示活动持续的时间。 AOE网可用来估算工程的完成时间。由于整个工程只有一个开始点和一个完成点，故在正常的情况（无环）下，网中只有一个入度为零的点（源点）和一个出度为零的点（汇点）。 **关键路径：**路径长度最长的路径。 最早发生时间： 假设开始点是v1，从v1到vi的最长路径长度叫做事件vi的最早发生时间。 这个时间决定了所有以vi为尾的弧所
算法：求解AOE网的关键路径
Meditation
05-02 1万+
前面我们简要地介绍了AOE网和关键路径的一些概念，本文接着对求解关键路径程序的主要函数进行分析。现有一AOE网图如图7-9-4所示，我们使用邻接表存储结构，注意与拓扑排序时邻接表结构不同的地方在于，这里弧表结点增加了weight域，用来存储弧的权值。 求解事件的最早发生时间etv的过程，就是我们从头至尾找拓扑序列的过程，因此在求关键路径之前，需要先调用一次拓扑序列算法的代码来计算etv
AOE网与关键路径
_临时工先森的博客
08-08 1393
AOE网   有向图中，用顶点表示活动，用有向边表示活动之间开始的先后顺序，则称这种有向图为AOV（Activity On Vertex）网络；AOV网络可以反应任务完成的先后顺序（拓扑排序）。   在AOV网的边上加上权值表示完成该活动所需的时间，则称这样的AOV网为AOE（Activity On Edge）网。   图中，顶点表示事件（特征属性：最早发生时间Ve(j);最晚发生时间V...
数据结构关键路径AOE网
02-13
在这个项目中，我们将使用数据结构中的图来表示关键路径问题，并通过读取字符文件来构建AOE（Activity On Edge）网络，这是一种特殊的有向无环图（DAG），其中边表示活动，节点表示事件。 首先，我们需要理解AOE...
Java 编写的AOE网络求关键路径
08-25
总之，Java编写AOE网络求关键路径的实现涉及数据结构、图论、算法以及GUI设计等多个方面，是软件工程领域中一项综合性的技能。通过掌握这项技术，开发者不仅可以有效地管理项目进度，还能提高工作效率，确保项目按期...
求AOE网络关键路径
07-09
在C++中实现AOE网络的关键路径算法，可以提供良好的性能和可维护性。 以下是一些关于AOE网络和关键路径计算的基本概念和步骤： 1. **节点与边**：在AOE网络中，节点（或顶点）代表项目中的活动，边则表示活动之间...
图论- AOE 网与关键路径.rar
09-16
掌握图论中的AOE网与关键路径知识对于软件开发、系统分析、项目管理等领域的专业人士来说极为重要，它可以帮助他们更高效地规划和执行复杂项目，提高工作效率，减少不必要的延误。因此，深入理解和应用这些理论是...
AoE算法求解关键路径
05-17
传统AoE算法求解关键路径的C++代码实现
关键路径和最短路径
12-12
关键路径
AOE网和关键路径
不吃鱼的猫的博客
12-07 6384
AOE网 抽象地看，AOE网是一种无环的带权有向图，其中： 顶点表示事件，有向边表示活动，边上的权值通常表示活动的持续时间。 图中一个顶点表示的事件，也就是它的人边所表示的活动都已完成，它的出边所表示的活动可以开始的那个状态，把这一情况看作事件。 实际工程或复杂事务里的一批相关活动（工作项目、任务等），可以用一个AOE网描述（抽象），然后就可以基于这个网考虑活动的安排了。  下图给出的AO...
AOE网与关键路径简介
weixin_34409703的博客
02-26 382
前面我们说过的拓扑排序主要是为解决一个工程能否顺序进行的问题，但有时我们还需要解决工程完成需要的最短时间问题。如果我们要对一个流程图获得最短时间，就必须要分析它们的拓扑关系，并且找到当中最关键的流程，这个流程的时间就是最短时间。 在前面讲了AOV网的基础上，来介绍一个新的概念。在一个表示工程的带权有向图中，用顶点表示事件，用有向边表示活动，用边上的权值表示活动的持续时间，这种有向图的边表示活动的网...
C语言AOE网、关键路径
记录学习点滴
05-01 3830
目录 1.AOE网（Activity On Edge Network） 1.1AOE网的概念 1.2AOE网两个顶点 2.关键路径 2.1关键路径的概念 2.2关键路径的几点说明 2.3关键路径的求解步骤 2.4关键路径求解示例 1.AOE网（Activity On Edge Network） 1.1AOE网的概念 若在带权的有向图中，用有向边表示活动（子工程），边上的权值表...
数据结构之图的生成树和最小生成树、AOE网和拓扑排序、关键路径
qq_38181811的博客
04-11 1008
相关概念： 通过对图的遍历，由遍历过程中使用到的边和顶点（顶点一定是都用上了，但是边只用了一部分，产生的效果就是，顶点都只和一个或者两个顶点邻接而已），这个子图称为原图的生成树。 按照遍历的方式的不同，称为深度优先生成树、广度优先生成树。 最小生成树：对于边是有权的话，生成树的所有边的权值之和就是生成树的权。其权值之和最小的生成树称为该图的最小生成树（Minimum Spanning Tree，M...
拓扑排序——关键路径(AOE网络基本概念和模板题)
测试
10-07 686
AOE网络：在现代化管理中，人们常用有向图来描述和分析一项工程的计划和实施过程，一个工程常被分为多个小的子工程，这些子工程被称为活动（Activity)，在带权有向图中若以顶点表示事件，有向边表示活动，边上的权值表示该活动持续的时间，这样的图简称为AOE网。答案是否定的，如下图:其中1,3,4,6,都是关键事件，关键路径也是1-3-4-6，其中3和6之间的活动不是关键活动，意味着不能在得到关键事件之后，直接输出所有关键事件之间的所有活动。关键路径可能有多条，所有关键路径上的节点事件都被称为关键事件。
数据结构总结15——图6——关键路径（AOE网关键路径算法） by DexterYan
qq_41259302的博客
07-02 1050
一、基础知识 二、代码要求 邻接矩阵、邻接表中任选一种作为图的存储结构，AOE网关键路径算法，实现从AOE网源点到汇点的关键路径（2学时） 三、算法思路分析 四、算法反思 五、代码实现 #include<stdio.h> #include<stdlib.h> #define MaxVertexNum 100 typedef char VertexType; typedef ...
关键路径 AOE 拓扑排序 最短工期 java
aiwo1376301646的博客
06-22 1642
拓扑排序是关键路径实现的基础 有两种实现方式： 1：dfs https://blog.csdn.net/aiwo1376301646/article/details/93350103 2：queue https://blog.csdn.net/aiwo1376301646/article/details/93353861 关键路径 代码参考博客，真心推荐，代码既短又清晰 https...
设计算法求解AOE网的关键路径
最新发布
06-12
求解 AOE 网的关键路径可以使用拓扑排序和动态规划的方法。 步骤如下： 1. 对 AOE 网进行拓扑排序，得到各个节点的拓扑序列。 2. 对每个节点进行动态规划，计算出其最早...以上就是求解 AOE 网的关键路径的算法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值