关键路径 订阅
关键路径是指设计中从输入到输出经过的延时最长的逻辑路径。优化关键路径是一种提高设计工作速度的有效方法。一般地,从输入到输出的延时取决于信号所经过的延时最大路径,而与其他延时小的路径无关。在优化设计过程中关键路径法可以反复使用,直到不可能减少关键路径延时为止。EDA工具中综合器及设计分析器通常都提供关键路径的信息以便设计者改进设计,提高速度。 [1] 展开全文
关键路径是指设计中从输入到输出经过的延时最长的逻辑路径。优化关键路径是一种提高设计工作速度的有效方法。一般地,从输入到输出的延时取决于信号所经过的延时最大路径,而与其他延时小的路径无关。在优化设计过程中关键路径法可以反复使用,直到不可能减少关键路径延时为止。EDA工具中综合器及设计分析器通常都提供关键路径的信息以便设计者改进设计,提高速度。 [1]
信息
发    明
杜邦公司
别    称
要径法
应用学科
数学 运筹学 计算机
中文名
关键路径
应    用
计划项目活动
外文名
Critical Path
关键路径介绍
关键路径通常(但并非总是)是决定项目工期的进度活动序列。它是项目中最长的路径,即使很小浮动也可能直接影响整个项目的最早完成时间。关键路径的工期决定了整个项目的工期,任何关键路径上的终端元素的延迟在浮动时间为零或负数时将直接影响项目的预期完成时间(例如在关键路径上没有浮动时间)。 [2]  但特殊情况下,如果总浮动时间大于零,则有可能不会影响项目整体进度。一个项目可以有多个、并行的关键路径。另一个总工期比关键路径的总工期略少的一条并行路径被称为次关键路径。最初,关键路径方法只考虑终端元素之间的逻辑依赖关系。关键链方法中增加了资源约束。关键路径方法是由杜邦公司发明的。
收起全文
精华内容
下载资源
问答
  • 所谓关键路径就是,在电路中频繁调用,而且延迟过长,或者产生意外的几率比较大的线路。
  • PMP关键路径终极例题

    2018-08-25 14:06:38
    关键路径法是PMP必考的知识点,我们在编写《PMBOK指南》第六版辅导教材(暂定书名《PMP考试全解读》)的过程中,对其进行了详细的整理说明,除了明确考试的重点,还对其中考生常见的模棱两可的知识点进行了图解说明...
  • 关键路径的算法演示过程,指用顶点表示活动,用弧表示活动间的优先关系的有向图称为顶点表示活动的网。
  • 图的关键路径算法实现。C语言实现,基于数据结构(C语言版)实现。
  • 为了提高资源行为动态异构的云环境中工作流任务的调度效率,提出了一种基于动态关键路径的工作流调度算法CWS-DCP。将工作流任务结构定义为有向无循环图DAG模型,改进了传统关键路径的一次性搜索模式,结合云资源可用...
  • 主要介绍了图的应用(最小生成树、拓扑排序、关键路径、最短路径),需要的朋友可以参考下
  • 数据结构 课程设计报告 课程题目关键路径 学 院 班 级 学 号 姓 名 指导教师 完成日期 目录 TOC \o "1-1" \h \z \u 一需求分析 3 二概要设计 4 三详细设计 5 四 调试分析 11 五 用户使用说明 12 六 测试结果 12 七 ...
  • 由于AOE网中的某些活动能够同时进行,故完成整个工程所必须花费的时间应该为始点到终点的最大路径长度。关键路径长度是整个工程所需的最短工期。
  • 关键路径和最短路径

    2016-12-12 15:40:03
    关键路径
  • 关键路径的权值和,并且从源点输出关键路径上的路径(如果有多条,请输出字典序最小的) 输入样例 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 8 9 4 7 9 2 输出样例 18 1 2 2 5 5 7 7 9
  • 拓扑排序与关键路径,在日常生活中,一项大的工程可以看作是由若干个子工程(这些子工程称为“活动” )组成的集合,这些子工程(活动)之间必定存在一些先后关系,即某些子工程(活动)必须在其它一些子工程(活动...
  • 关键路径管理
  • 关键路径关键路径方法(CPM)是一种算法,用于项目管理中以计划一组项目活动。 该程序(cpm)是关键路径法算法的实现,该算法可以以最小的总成本和最佳的持续时间来计划一组项目活动。 建筑学 核心组件是cpm.py...
  • 关键路径

    千次阅读 2019-04-25 14:19:34
    为了求出关键路径,我们使用一下算法: 1.求出到达各个状态的最早时间(按最大计) 这个过程是要从源点开始向汇点顺推: V1是源点,其最早开始时间是0。 V2、V3、V4最早时间分别是是6、4、5。 对于V5而言,V2到...

    原理:

    例图

     

    如上图,是一个AOE网,点表示状态,边表示活动及其所需要的时间。为了求出关键路径,我们使用一下算法:

    1.求出到达各个状态的最早时间(按最大计)


    这个过程是要从源点开始向汇点顺推:

    1. V1是源点,其最早开始时间是0。
    2. V2、V3、V4最早时间分别是是6、4、5。
    3. 对于V5而言,V2到V5所花费时间是6+1=7,而V3到V5所花费时间是4+1=5。我们要按最大计,也就是V5最早时间是max{7,5}=7,按最大计是因为只有活动a4和a5同时完成了,才能到达V5状态。V3到V5需要5分钟,但是此时a4活动尚未完成(7分钟),所以都不能算到达V5,故而要按最大计。
    4. V6只有从V4到达,所以V6的最早完成时间是(5+2=)7。
    5. 同理,V7最早完成时间是16。
    6. 对于V8而言,和V5处理方法一致。V8=max{V5+7,V6+4}={7+7,7+4}=14。
    7. V9可算出是18。

    这样,我们可以得到各个状态的最早时间的表:

    最早时间表

    2.求出到达各个状态的最晚时间(按最小计)


    这个过程是要从汇点开始向源点逆推:

    1. V9完成时间为18,最V7最迟开始时间是(18-2=)16

      逆推


      因为活动a10所需时间2。如果V7开始时间比16晚,则V9完成时间就会比18晚,这显然不对。
    2. 同理,V8最迟开始时间为14。
    3. 对于V5而言,可以从V7、V8两个点开始向前推算,此时要按最小计,即V5(最晚)=min{V7-9,V8-7}=min{16-9,14-7}=7。
      请注意!!,min{V7-9,V8-7}中,V7、V8取的都是前面算出的最迟开始时间(而不是最早开始时间)。

      按最小计


      最小计,是因为如果按最大计去计算V5的最晚开始时间,那么加上a7和a8的活动时间后,V7、V8至少有一个会比之前逆推算得出的最晚时间还要晚,这就发生了错误。
    4. 同理,可计算出剩下的点

    这样,我们可以得到各个状态的最晚时间的表:

    最晚时间表

     

    事实上,源点和汇点的最晚时间和最早时间必定是相同的。

    3.求出关键路径


    求出关键活动,则关键活动所在路径即为关键路径

    对于a1:

     

    这表明,a1最早只能从0时刻开始,最晚也只能从(6-6=)0时刻开始,因此,a1是关键活动。

    对于a2:

     


    a2最早要从0时刻开始,但是它最晚开始时间却是(6-4=)2。也就是说,从0开始做,4时刻即完成;从2开始做,6时刻恰好完成。从而在[0,2]区间内任意时间开始做a2都能保证按时完成。(请区别顶点的最早最晚和活动的最早最晚时间。图示中的最早最晚是顶点状态的时间,活动的最早最晚开始时间却是基于此来计算的)。
    由于a2的开始时间是不定的,所以它不能主导工程的进度,从而它不是关键活动。

     

    一般的,

     


    活动用时X时间,它最早要从E1时刻开始(一开始就开始),最晚要从L2-X时刻开始(即恰好完成)。所以,如果它是关键活动,则必然有E1=L2-X,否则它就不是关键活动。

     

    值得注意的是,顶点的最早开始时间等于最晚开始时间 是 该顶点处于关键路径 的 不充分不必要条件。

     


    上表中蓝色底纹表示的点即为处于关键路径的点。尽管它们的最早时间与最晚时间都相同,但是这与它们是否为关键路径的点无关。因为这还取决于起始点的最早时间以及活动时间。

     

    关键路径


    原文:https://www.jianshu.com/p/1857ed4d8128

     

    代码实现:

    设一个工程有11项活动,9个事件,事件V1 ----- 表示整个工程开始,事件V9 ----- 表示整个工程结束。

    每个事件的开始必须是它之前的活动已完成。例如:事件V2,V3,V4的开始必须是活动a1,a2,a3完成了。

    这时我们会关注两个问题:

    (1)完成整个项目需要多少时间?

    (2)哪些活动是影响工程进度的关键?
    定义:

    关键路径:AOE-网中,从起点到终点最长的路径的长度(长度指的是路径上边的权重和)

    关键活动:关键路径上的活动

    AOE网:也叫边表示活动的网。AOE网是一个带权的有向无环图,其中顶点表示事件,弧表示活动,权表示活动持续的时间。

    Ve[j] :表示事件j 的最早发生时间

    VI[j]: 表示事件j 的最迟发生时间

    e[i]:表示活动ai的最早开始时间

    l[i]:表示活动ai的最迟开始时间
    方法:

    以邻接矩阵作为存储结构

    1、从原点V1出发,令Ve[1] = 1,拓扑排序求各个顶点的Ve[i]

    2、从Vn出发,令Vl[n] = Ve[n] ,逆拓扑排序求出各个顶点的Vl[i]

    3、根据各顶点的Ve和Vl值,计算每条弧的e[i] 和 l[i],找出e[i] = l[i] 的关键活动

    简单来说:

    顺拓扑排序取大值求出Ve数组,逆拓扑序列取小值求出Vl数组,最后找出Ve[i] = Vl[i] 的顶点,即关键路径上的顶点,将这些顶点连接起来的路径叫关键路径。
    实现:
    手动实现:

     
    代码实现:

        #include <iostream>
        #include <cstring>
        using namespace std;
        #define N 13
        int main()
        {
            int map[N][N]; //邻接矩阵
            // 初始化矩阵的值全部为0表示各个顶点间没有边连接
            for(int i = 0; i <= N-1; i++){
                for(int j = 0; j <= N-1; j++){
                    map[i][j] = -1;
                }
            }
         
            int a,b,values;  //定义a,b,用来输入,values存储权值
            int v,l;  //顶点数和边数
         
            cout << "请输入顶点数:";
            cin >> v;
            cout << "请输入边数:";
            cin >> l;
            cout << "请输入边:" << endl;
         
            for(int i = 1; i <= l; i++){
                    cin >> a >> b >> values;
                    map[a][b] = values; // 表示顶点a指向顶点b的边,且权值为values
            }
         
            int k; //用于计算度数
            int ID[N],OD[N];  //储存各顶点的入度和出度
            int ve[N],vl[N];  //顺拓扑序列取大,逆拓扑序列取小
            memset(ve,0,sizeof(ve));  //初始化ve数组全为0
         
            for(int i = 1; i <= v; i++){  // 计算入度
                k = 0;
                for(int j = 1; j <= v; j++){
                    if(map[j][i] != -1) //如果顶点j到顶点i有边,则顶点i的入度+1
                        k++;
                }
                ID[i] = k;
            }
            for(int i = 1; i <= v; i++){  //顺拓扑序列
                if(ID[i] == 0){
                    for(int j = 1; j <= v; j++){
                        if(map[i][j] != -1){     //如果顶点j与顶点i有边,则删除这条边,并且顶点j的入度-1
                            if(ve[j] < map[i][j] + ve[i])  //取大值
                                ve[j] = map[i][j] + ve[i];
                            ID[j]--;
                        }
                    }
                }
            }
            for(int i = 1; i <= v; i++){  // 计算出度
                k = 0;
                for(int j = 1; j <= v; j++){
                    if(map[i][j] != -1)
                        k++;
                }
                OD[i] = k;
            }
         
            k = v;
            for(int i = 1; i <= v; i++)    //将 vl 数组全部初始化为ve最后一顶点的值
               vl[i] = ve[k];
         
            for(int i = k; i>=1; i--){  //逆拓扑序列
                if(OD[i] == 0){
                    for(int j = 1; j <= v; j++){
                        if(map[j][i] != -1){
                            if(vl[j] > vl[i] - map[j][i])   //取小值
                                vl[j] = vl[i] - map[j][i];
                            OD[j]--;
                        }
                    }
                }
            }
            cout << "****************************\n";
            cout << "Ve数组:";
            for(int i = 1; i <= k; i++){
                cout << ve[i] << " ";
            }
            cout << endl;
            cout << "Ve数组:";
            for(int i = 1; i <= k; i++){
                cout << vl[i] << " ";
            }
            cout << "\n****************************\n";
         
            cout << "关键路径:";
            for(int i = 1; i <= k - 1; i++){
                if(ve[i] == vl[i]){
                    cout << i << "->";
                }
            }
            cout << k << endl;
            return 0;
        }

    结果:

     

    原文:https://blog.csdn.net/qq_37618797/article/details/81114696

    展开全文
  • 工业互联网:数字化转型的关键路径.pdf
  • 本文档对信息系统项目中的关键路径计算、总时差、自由时差的概念进行解释
  • 第7章 图7.1 图的定义和术语7.2 图的存储结构7.3 图的遍历7.4 图的连通性问题7.5 有向无环图及其应用 7.5.1 拓扑排序 7.5.2 关键路径7.6 最短路径7.5.2 关键路径 对整个工程和系统人们关心的是两个方面的问题 1工程...
  • 在Windows7 64位+VS2015上运行求解AOE网关键路径的算法,邻接表表示的AOE网提示网中有回路,邻接矩阵表示的AOE网显示正确的信息?使用的算法是一样的,两种方法的相关类的接口函数也一致,为什么会出现这种问题?
  • 每千次展示费用 关键路径法(或关键路径分析),使用它来进行关键路径分析。 在其他开放源代码项目(例如JUNG,Joda-Time和DateCalc)的帮助下用Java编写。
  • C语言数据结构的重要部分——图,还有一个工程中常用的排序——拓扑排序,引入了栈的思想,对工程进行关键路径查询,学习数据结构的朋友可以看看噢!内附具体代码
  • 从仿真系统工作流的关键路径分析,确定关键路径上的联邦成员节点,使网格资源调度方面优先获得保证。鉴于仿真网格系统运行的复杂性和不确定性,引入了随机规划理论,提出了仿真网格的动态关键路径概念以及基于动态...
  • 本资料主要是关于FPGA的设计技巧以及一些关键路径的分析指导
  • 关键路径算法

    2012-12-25 01:39:19
    利用邻接表,拓扑排序求关键 用邻接表实现关键路径的求值
  • 关键路径计算

    2013-03-28 09:57:52
    关键路径计算方法,讲解的比较详细,看完后此类型的题可以迎刃而解!
  • 拓扑排序关键路径算法C语言完整代码,vs2013下编译运行通过
  • CPM关键路径

    2018-07-12 15:55:55
    CPM(CriticalPathMethod关键路径法)是项目管理中最基本也是非常关键的一个 概念,它上连着WBS(工作分解结构),下连着执行进度控制与监督。关键路径是 项目计划中最长的路线。它决定了项目的总实耗时间。项目经理必须...
  • 本代码实现java实现带权无环图关键路径的查找,使用者可根据自身需要进行修改
  • 关键路径问题讲解,解决最早开始时间,最晚开始时间的问题。
  • 关键路径详解

    千次阅读 2019-11-22 15:46:36
    ),而把关键路径上的活动称为关键活动,显然关键活动会影响整个工程的进度。 关键概念: 1. 事件的最早发生时间 ve[k] ( earliest time of vertex ):即 顶点 vk 的最早发生时间。 从源点向终点方向...

    AOV网:

    顶点活动(Activity On VertexAOV)网是指用顶点表示活动,而用边集表示活动间优先关系的有向图。例如图10-57的先导课程示意图就是AOV网,其中图的顶点表示各项课程,也就是“活动”;有向边表示课程的先导关系,也就是“活动间的优先关系”。显然,图中不应当存在有向环,否则会让优先关系出现逻辑错误。

    AOE网:

     

    边活动(Activity On EdgeAOE)网是指用带权的边集表示活动,而用顶点表示事件的有向图,其中边权表示完成活动需要的时间。例如图10-59中,边a1~a6表示需要学习的课程,也就是“活动”,边权表示课程学习需要消耗的时间;顶点V1~V6。表示到此刻为止前面的课程已经学完,后面的课程可以开始学习,也就是“事件”(如V5表示a4计算方法和a3实变函数已经学完,a6泛函分析可以开始学习。从另一个角度来看,a6只有当a4a5都完成时才能开始进行,因此当a4计算方法学习完毕后必须等待a5实变函数学习完成后才能进入到a6泛函分析的学习),显然“事件”仅代表一个中介状态。

    源点:AOE网中,没有入边的顶点称为源点;如顶点V1

     

    终点:在AOE网中,没有出边的顶点称为终点;如顶点V6

     

    AOE网的性质:

    ·只有在进入某顶点的活动都已经结束,该顶点所代表的事件才发生;

    ·只有在某顶点所代表的事件发生后,从该顶点出发的各活动才开始;

    AOE网中的最长路径被称为关键路径(强调:关键路径就是AOE网的最长路径),而把关键路径上的活动称为关键活动,显然关键活动会影响整个工程的进度。

    关键概念:

    1.事件的最早发生时间ve[k]earliest time of vertex):即顶点vk的最早发生时间。

    从源点向终点方向计算

    ve[0] = 0

    ve[1] = ve[0] + a0 = 0 + 4 = 4

    ve[2] = max( ve[0] + a1, ve[1] + a2 ) = max(0 + 3, 4 + 2 = 6

    ve[3] = max(ve[1] + a4, ve[2] + a3) = max(4 + 6, 3 + 4) = 10

     

    2.事件的最晚发生时间vl[k]latest time of vertex):即顶点vk的最晚发生时间,也就是每个顶点对应的事件最晚需要开始的时间,超出此时间将会延误整个工期。

    从终点向源点方向计算

    vl[3] = ve[3] = 10

    vl[2] = vl[3] - a3 = 10 - 4 = 6

    vl[1] = min(vl[3] - a4, vl[2] - a2) = min(10-6, 6-2) = 4//之所以求最小,保证其他的点的最晚发生时间

    vl[0] = min(vl[2] - a1, vl[1] - a0) = min(4-4, 4-2) = 0 

     

    3.活动的最早开工时间e[k]earliest time of edge):即ax的最早发生时间。

    5条边,5个活动

    e[0] = ve[0] = 0

    e[1] = ve[0] = 0

    e[2] = ve[1] = 4

    e[3] = ve[2] = 6

    e[4] = ve[1] = 4

     

    4.活动的最晚开工时间l[k]latest time of edge):即ak的最晚发生时间,也就是不推迟工期的最晚开工时间。

    e[0] = v[1] - a0 = 4 - 4 = 0

    e[1] = vl[2] - a1 = 6 - 3 = 3

    e[2] = vl[2] - a2 = 6 - 2 = 4

    e[3] = vl[3] - a3 = 10 - 4 = 6

    e[4] = vl[3] - a4 = 10 - 6 = 4

     

    活动的最早开始时间最晚开始时间等,则说明该活动时属于关键路径上的活动,即关键活动

    算法设计:

    关键路径算法是一种典型的动态规划法,设图G=(V, E)是个AOE网,结点编号为1,2,...,n,其中结点1n 分别为始点和终点,ak=<i, j>EG的一个活动。算法关键是确定活动的最早发生时间ve[k]最晚发生时间vl[k],进而获取顶点的最早开始时间e[k]和最晚开始时间l[k]

    根据前面给出的定义,可推出活动的最早及最晚发生时间的计算方法:

    e(k) = ve(i)

    l(k) = vl(j) - len(i,j)

    结点的最早发生时间的计算,需按拓扑次序递推:

    ve(1) = 0

    ve(j) = MAX{ etv(i)+len(i, j) }

     

    对所有<i,j> Ei  结点的最晚发生时间的计算,需按逆拓扑次序递推:

    vl(n) = ve(n)

    vl(i) = MIN{vl(j) - len(i, j)} 对所有<i,j>E的j

     

    这种计算方法, 依赖于拓扑排序, 即计算ve( j) 前,应已求得j 的各前趋结点的ve值,而计算vl(i)前,应已求得i的各后继结点的vl值。ve的计算可在拓扑排序过程中进行,即在每输出一个结点i后,在删除i的每个出边<i,j>(即入度减1)的同时,执行

    if ( ve[i]+len(i,j)) > ve[j] )

    ve[j] = ve[i] + len(i,j)

     

    这时会发现,如果想要获得ve[j]的正确值,ve[il]~ve[ik]必须已经得到。有什么办法能够在访问某个结点时保证它的前驱结点都已经访问完毕呢?没错,使用拓扑排序就可以办到。

    当按照拓扑序列计算ve数组时,总是能保证计算ve[i]的时候ve[il]~ve[ik]都已经得到。但是这时又碰到另一个问题,通过前驱结点去寻找所有后继结点很容易,但是通过后继结点V;去寻找它的前驱结点V1~Vx似乎没有那么直观。一个比较好的办法是,在拓扑排序访问到某个结点时,不是让它去找前驱结点来更新ve[i],而是使用ve[i]去更新其所有后继结点的ve。通过这个方法,可以让拓扑排序访问到V;的时候,V1~Vk一定都已经用来更新过ve[i],此时的ve[i]便是正确值,就可以用它去更新V;的所有后继结点的ve值。

    //拓扑序列
    
    stack<int>topOrder;
    
    //拓扑排序,顺便求ve数组
    
    bool topologicalSort()
    
    {
    
        queue<int>q;
    
        for(int i=0;i<n;i++)
    
            if(inDegree[i]==0)
    
                q.push(i);
    
        while(!q.empty())
    
        {
    
            int u=q.front();
    
            q.pop();
    
            topOrder.push(u);//将u加入拓扑序列
    
            for(int i=0;i<G[u].size();i++)
    
            {
    
                int v=G[u][i].v;//u的i号后继结点编号为v
    
                inDegree[v]--;
    
                if(inpegree[v]==0)
    
                    q.push(v);
    
                //用ve[u]来更新u的所有后继结点
    
                if(ve[u]+G[u][i].w> ve[v])
    
                    ve[v]=ve[u]+G[u][i].w;
    
            }
    
        }
    
        if(toporder.size()== n)
    
            return true;
    
        else
    
            return false;
    
    }

    同理,如图10-64所示,从事件V出发通过相应的活动ar1~ark可以到达k个事件V1~Vk,活动的边权为length[r1]~length[rk]。假设已经算好了事件V1~Vk的最迟发生时间xl[j1]vl[jk],那么事件Vi的最迟发生时间就是vl[j1]-length[r1]~vl[jk]-length[rk]中的最小值。此处取最小值是因为必须保证Vj1~Vjk的最迟发生时间能被满足;可以通过下面这个公式辅助理解。

     和ve数组类似,如果需要算出vl[i]的正确值,vl[j1]~vl[jk]必须已经得到。这个要求与ve数组的刚好相反,也就是需要在访问某个结点时保证它的后继结点都已经访问完毕,而这可以通过使用逆拓扑序列来实现。幸运的是,不必再做一次逆拓扑排序来得到逆拓扑序列,而是可以通过颠倒拓扑序列来得到一组合法的逆拓扑序列。此时会发现,在上面实现拓扑排序的过程中使用了栈来存储拓扑序列,那么只需要按顺序出栈就是逆拓扑序列。而当访问逆拓扑序列中的每个事件Vi时,就可以遍历Vi的所有后继结点Vj1~Vjk,使用vI[j1]~vl[jk]来求出vl[i]。

    这部分的代码如下所示:

    fill(vl,v1+n,ve[n-1]);//v1数组初始化,初始值为终点的ve值
    
    //直接使用toporder出栈即为逆拓扑序列,求解v1数组
    
    while(!topOrder.empty())
    
    {
    
        int u=topOrder.top();//栈顶元素为u
    
        topOrder.pop();
    
        for(int i=0;i<G[u].size();i++)
    
        {
    
            int v=G[u][i].v;//u的后继结点v
    
            //用u的所有后继结点v的v1值来更新v1[u]
    
            if(vl[v]-G[u][i].w < vl[u])
    
                vl[u]=vl[v]-G[u][i].w;
    
        }
    
    }
    
    

            通过上面的步骤已经把求解关键活动的过程倒着推导了一遍,下面给出上面过程的步骤总结,即“先求点,再夹边”

    ①按拓扑序和逆拓扑序分别计算各顶点(事件)的最早发生时间和最迟发生时间:

    ②用上面的结果计算各边(活动)的最早开始时间和最迟开始时间:

    e[i-] = l[i-i]的活动即为关键活动。

    主体部分代码如下(适用汇点确定且唯一的情况,以n-1号顶点为汇点为例):【主体代码】

    求取关键路径:

    
    //遍历邻接表的所有边,计算活动的最早开始时间e和最迟开始时间1
    
    for(int u=0;u<n;u++)
    
    {
    
        for(int i=0;i<G[u].size();i++)
    
        {
    
            int v=G[u][i].v,w=G[u][i].w;
    
            //活动的最早开始时间e和最迟开始时间1
    
            int e=ve[u],l=vl[v]-w;
    
            //如果e==1,说明活动u->v是关键活动
    
            if(e==1)
    
            printf("%d->%d\n",u,v);//输出关键活动}
    
        }
    
        return ve[n-1];//返回关键路径长度
    
    }

     

     

    在上述代码中,没有将活动的最早开始时间e和最迟开始时间l存储下来,这是因为一般来说el只是用来判断当前活动是否是关键活动,没有必要单独存下来。如果确实想要将它存储下来,只需要在结构体Node中添加域e1即可。

    如果事先不知道汇点编号,有没有办法比较快地获得关键路径长度呢?当然是有办法的,那就是取ve数组的最大值。原因在于,ve数组的含义是事件的最早开始时间,因此所有事件中ve最大的一定是最后一个(或多个)事件,也就是汇点。于是只需要在fill函数之前添加一小段语句,然后改变下vl函数初始值即可,代码如下:

    int maxLength = 0;
    
    for(int i=0; i<n; ++i)
    
    {
    
        if(ve[i] > maxLength)
    
            maxLength = ve[i];
    
    }
    
    fill(vl, vl + n, maxLength);

     

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 442,539
精华内容 177,015
关键字:

关键路径