精华内容
下载资源
问答
  • 数据结构课本上的求关键路径的算法,注释详细,应该对着书看都能懂的,基本都是书上的思路
  • 数据结构与算法——AOE网关键路径 AOE是带权值的有向图,以顶点表示事件,以边表示活动,边上的权值表示活动的开销(如项目工期)。AOE 是建立在子过程之间的制约关系没有矛盾的基础之上,再来分析整个过程需要的...

    数据结构与算法——AOE网的关键路径

    在一个表示工程的带权有向图中,用顶点表示事件,用有向边表示活动,用边上的权值表示活动的持续时间,这种有向图的边表示活动的网,称之为AOE网。

    AOE网 是建立在子过程之间的制约关系没有矛盾的基础之上,再来分析整个过程需要的开销。所以如果给定AOV网中各顶点活动所需要的时间,则可以转换为AOE网,较为简单的方法就是把每个顶点都拆分成两个顶点,分别表示活动的起点和终点

    把上图转换成一般的AOE图如下:

    看图分析:

    上图为AOE网和AOE转为邻接表结构的存储示意图,其中在边链表中添加weight用于表示活动的权值,数据结构如下;

    #include <iostream>
    using namespace std;
    #define MAXVER 14

    typedef struct EdgeNode
    {
        int adjvex;
        int weight;
        struct EdgeNode *next;
    }EdgeNode;

    typedef struct VertexNode 
    {
        int in;
        int data;
        EdgeNode* firstedge;
    }VertexNode,AdjList[MAXVER];

    typedef struct 
    {
        AdjList adjList;
        int numVertexes, numEdge;
    }graphAdjList,*GraphAdjList;

    关键路径算法描述

    1. 关键路径是AOE网中的最长路径,也是整个工程的最短完成时间;

    2. 在关键路径的算法过程中,这两个概念:
         a. 事件(顶点)的最早发生时间:前导事件和活动全部完成时间,就是该事件最早发生的时间;
         b. 事件的最晚发生时间:逆向思考,后一个事件发生的时间,除去该事件需要活动的时间差,为该事件的最迟发生时间;

    3. 如果一个事件的最迟发生时间 等于 该事件的最早发生时间,那么弧就是关键活动了,因为它直接决定了这个工程完成的时间

    关键路径实现源码

    int *etv, *ltv;
    int *stack2;
    int top2;

    bool TopologicalSort(GraphAdjList GL) 
    {
        EdgeNode *e;
        int i, k, gettop;
        int top = 0;
        int count = 0;
        int *stack;

        stack = (int*)malloc(GL->numVertexes*sizeof(int));

        for (i = 0; i < GL->numVertexes; i++) 
        {
            if (0 == GL->adjList[i].in) 
            {
                stack[++top] = i;
            }
        }

        top2 = 0;
        etv = (int*)malloc(GL->numVertexes*sizeof(int));

        for (i = 0; i < GL->numVertexes; i++)
            etv[i] = 0;

        stack2 = (int*)malloc(GL->numVertexes * sizeof(int));

        while ( top != 0 ) 
        {
            gettop = stack[top--];
            count++;

            //将弹出的入度为0的顶点放入stack2中
            //有别于stack,这里是遍历的顺序
            stack2[++top2] = gettop;

            for (e = GL->adjList[gettop].firstedge; e; e = e->next) 
            {
                k = e->adjvex;
                if (!(--GL->adjList[k].in))
                {
                    stack[++top] = k;
                }

                if ((etv[gettop] + e->weight) > etv[k]) 
                {
                    etv[k] = etv[gettop] + e->weight;//记录事件发生最早的时间(理解这里的最早含义:是所有前导工作都完成)
                }
            }
        }


        if (count < GL->numVertexes)
            return false;
        else
            return true;

    }


    void CriticalPath(GraphAdjList GL) 
    {
        EdgeNode *e;
        int i, gettop, k, j;
        int ete, lte;
        TopologicalSort(GL);

        ltv = (int*)malloc(GL->numVertexes*sizeof(int));

        for ( i=0;i<GL->numVertexes;i++) 
        {
            ltv[i] = etv[GL->numVertexes - 1];//初始化为最后一个顶点发生的最小时间
        }

        while ( top2 != 0 ) 
        {
            gettop = stack2[top2--];//将拓扑序列出栈,注意这里是按照拓扑排序的逆序

            for (e = GL->adjList[gettop].firstedge;e;e = e->next) 
            {//求各顶点事件的最迟发生时间ltv值
                k = e->adjvex;
                //这里利用尾顶点的最迟发生时间 - 当前弧的权值来得到该顶点的最迟发生时间
                if (ltv[k] - e->weight < ltv[gettop]) 
                {
                    ltv[gettop] = ltv[k] - e->weight;
                }
            }

        }


        for (j = 0; j < GL->numVertexes;j++) 
        {

            for (e = GL->adjList[j].firstedge;e;e = e->next) 
            {
                k = e->adjvex;
                ete = etv[j];//最早发生时间
                lte = ltv[k] - e->weight;//最迟发生时间

                if (ete == lte)
                {
                    cout << "< " << GL->adjList[j].data << "," << GL->adjList[k].data << " > " << endl;
                }

            }

        }

    }

    展开全文
  • AOE图 工程最短工期 可以输出所有的关键路径
  • 一、AOE和AOV 1.AOE网 AOE-:指用边表示活动的,是一个带权的有向无环图,其中,顶点表示事件弧表示活动,权表示活动持续的时间,通常一个AOE-可用来估算工程的完成时间。 AOE网具有以下几个性质: (1) ...

    一、AOE和AOV网

    1.AOE网

    AOE-网:指用边表示活动的网,是一个带权的有向无环图,其中,顶点表示事件弧表示活动,权表示活动持续的时间,通常一个AOE-网可用来估算工程的完成时间。

    AOE网具有以下几个性质:

    (1) 只有在某顶点所代表的事件发生后,从该顶点出发的各有向边所代表的活动才能开始;

    (2) 只有在进入某一顶点的各有向边所代表的活动都已经结束,该顶点所代表的事件才能发生;

    (3) 表示实际工程计划的AOE网应该是无环的,并且存在惟一的入度过为0的开始顶点(源点)和惟一的出度为0的完成顶点(汇点)。

    对于AOE-网,我们不妨采用与AOV-网一样的邻接表的存储方式,其中邻接表中边结点增设一个dut域存放该边的权值,即该有向边代表的活动所持续的时间。

    下图给出了上图所示的AOE-网的邻接表。

    如果用AOE网来表示一项工程,那么仅仅考虑各个子工程之间的优先关系还不够,更多的是关心整个工程完成的最短时间是多少,哪些活动的延迟将会影响整个工程的进度,而加速这些活动又能导致提高整个工程的效率。因此,对AOE网有待研究的问题是:

    (1) 完成整个工程至少需要多少时间;

    (2) 哪些活动是影响工程进度的关键。

    二、关键路径

    由于在AOE-网中某些活动可以并行地进行,因此完成工程的最短时间是从开始顶点(源点)到完成顶点(汇点)的最大路径长度(这里所说的路径的长度等于这条路径上完成各个活动所需时间之和,不是路径上弧的数目);具有最大路径长度的路径称为关键路径。

    为了寻找关键活动,确定关键路径,我们先定义几个变量:

    (1)事件的最早发生时间ve(i):从v1到vi的最长路径长度。

    (2)事件的最迟发生时间vl(i):完成顶点vn的最早发生时间ve(n)减去vi到vn的最长路径长度。

    (3)活动ai的最早开始时间e(i):事件vj的最早发生时间ve(j)也是所有以vj为起点的出边 vj, vk所表示的活动ai的最早开始的时间,即e(i)=ve(j)。

    (4)活动的最迟开始时间l(i):是ai的最迟完成时间减去ai的持续时间,即l(i)=vl(k)- vj , vk的权。通常把e(i)=l(i)的活动称为关键活动

    由上述分析可知,若把所有活动ai的最早开始时间e(i)和最迟开始时间l(i)都计算出来,即可找到所有的关键活动。为了求得AOE网的e(i)和l(i),应该先求得网中所有事件vj的最早发生时间ve(j)和最迟发生时间vl(j)。若活动ai由边vj, vk表示,其持续时间记为dut(j, k),则有如下关系:

    e(i)=ve(j)l(i)=vl(k)-dut(j, k)

    求关键路径的算法描述

    1) 根据有向网的弧建立图的邻接表作存储结构;

    2) 从源点v0出发,令ve[0]=0,按拓扑序列求各顶点的ve[i];

    3) 从汇点vn-1出发,令vl[n-1]=ve[n-1],按逆拓扑序列求其余各顶点的vl[i];

    4) 根据各顶点的ve和vl值,计算每条弧的e[i]和l[i],找出e[i]=l[i]的关键活动。

    算法实现

    1)输入顶点和弧信息,建立其邻接表;计算每个顶点的入度

    2)对其进行拓扑排序,排序过程中求顶点的ve[i],将得到的拓扑序列进栈

    3)按逆拓扑序列求顶点的vl[i]。计算每条弧的e[i]和l[i],找出e[i]=l[i]的关键活动。

    例如:根据给定的右图求该AOE-网的关键活动及关键路径。

    关键活动是:a1, a4, a7, a8, a10, a11

    它们构成了两条关键路径:(v1,v2,v5,v7,v9)和(v1,v2,v5,v8,v9)

    求出来的关键路径的图如下:

    说明:

    关键活动的速度提高是有限度的。任何一项活动持续时间的改变都会影响关键路径的改变;只有在不改变网的关键路径的情况下,提高关键活动的速度才有效。若网中有几条关键路径,单提高一条关键路径上的关键活动的速度,是不能导致整个工程缩短工期。必须同时提高在几条关键路径上的活动的速度。

    展开全文
  • AOE网中,从源点到汇点最长的路径称为关键路径,在关键路径上的活动称为关键活动。 因为AOE网中的活动是可以并行进行的,所以整个工程的时间开销,其实是最长路径的时间开销。即关键路径制约整个工程的工期。 &...

    相关概念

    AOE网

    AOE网(Activity On Edge Network)用边表示活动,用顶点表示事件(活动的完成)。边是带权的,表示活动需要的时间。

    源点与汇点

    源点:入度为0的点,表示一个工程的开始。

    汇点:出度为0的点,表示一个工程的结束。

    关键活动与关键路径

    在AOE网中,从源点到汇点最长的路径称为关键路径,在关键路径上的活动称为关键活动

    因为AOE网中的活动是可以并行进行的,所以整个工程的时间开销,其实是最长路径的时间开销。即关键路径制约整个工程的工期。

     
    >_< 看个图理解一下上面的定义吧!!!

    在这里插入图片描述

     
     
     

    加深理解

    通过AOV网与AOE网的比较,我们更能够深刻的理解二者。

    相同点

    都是有向无环图(DAG);都存在拓扑限制。

    不同点

    AOV网的顶点表示活动,边无权。AOV网用来分析活动之间的制约关系。

    AOE网的顶点表示事件(活动的完成),边表示活动,权值为活动的持续时间。AOE网用来分析工程的最小时间限制,也就是说,缩短哪些活动持续时间可以缩短整个工程的工期(关键活动),缩短哪些活动持续时间并没有意义(非关键活动)。

     
     
     

    关键路径算法(理论)


    在说关键路径算法之前,你需要弄懂下面的几个重要参量及其求法:

    事件 vk 的最早发生时间 ve(k) —— 它是从源点v1到某个顶点vk的最长路径长度。它决定了之后的活动能够开工的最早时间。

    ve(源点) = 0

    ve(k) = max{ve(j) + cost(j, k)}

    事件 vk 的最迟发生时间 vl(k) —— 它是指在不推迟整个工期的前提下,该事件最迟必须发生的事件。

    vl(汇点) = ve(汇点)

    vl(k) = min{vl(j) - cost(k, j)}

    活动 ai 的最早开始时间 e(i) —— 它是该活动的起点表示的事件的最早发生时间。

    活动为(k, j),则 e(i) = ve(k)

    活动 ai 的最迟开始时间 l(i) —— 它是该活动的终点表示的事件的最迟发生事件该活动所需时间之差。

    活动为(k, j),则 l(i) = vl(j) - cost(k, j)


    好了,下面正式介绍关键路径算法。

    1)从源点出发,令 ve(源点) = 0,按拓扑顺序求出所有顶点(事件)的最早发生时间 ve()

    2)从汇点出发,令 vl(汇点) = ve(汇点),按拓扑逆序求出所有顶点(事件)的最迟发生时间 vl()

    3)根据各顶点的 ve() 值求出所有边(活动)的最早开始时间 e()

    4)根据各顶点的 vl() 值求出所有边(活动)的最迟开始时间 l()

    5)e() = l() 的边构成关键路径;关键路径上的顶点为关键活动。

     
     
     

    关键路径算法(举例)

    题目如图:

    在这里插入图片描述

    具体流程:

    ve(1) = 0
    ve(2) = ve(1) + 3 = 3
    ve(3) = ve(1) + 2 = 2
    ve(4) = max{ve(2) + 2, ve(3) + 4} = max{5, 6} = 6
    ve(5) = ve(2) + 3 = 6
    ve(6) = max{ve(5) + 1, ve(4) + 2, ve(3) + 3} = max{7, 8, 5} = 8

    vl(6) = ve(6) = 8
    vl(5) = vl(6) - 1 = 7
    vl(4) = vl(6) - 2 = 6
    vl(3) = min{vl(4) - 4, vl(6) - 3} = min{2, 5} = 2
    vl(2) = min{vl(5) - 3, vl(4) - 2} = min{4, 4} = 4
    vl(1) = min{vl(2) - 3, vl(3) - 2} = min{1, 1, } = 1

    e(1) = ve(1) = 0
    e(2) = ve(1) = 0
    e(3) = ve(2) = 3
    e(4) = ve(3) = 3
    e(5) = ve(3) = 2
    e(6) = ve(3) = 2
    e(7) = ve(4) = 6
    e(8) = ve(5) = 6

    l(1) = vl(2) - 3 = 1
    l(2) = vl(3) - 2 = 0
    l(3) = vl(4) - 2 = 4
    l(4) = vl(5) - 3 = 4
    l(5) = vl(4) - 4 = 2
    l(6) = vl(6) - 3 = 5
    l(7) = vl(6) - 2 = 6
    l(8) = vl(6) - 1 = 7

    e(2) == l(2)
    e(5) == l(5)
    e(7) == l(7)

    最终结果:

    在这里插入图片描述

     
     
     

    补充说明

    ① 关键路径上的活动是关键活动,它是决定整个工程工期的关键因素,即通过加快关键活动来缩短整个工程的工期。但是注意关键活动的缩短存在一个下限,因为一旦缩短到一定的程度,这条路径就不再是关键路径,该关键活动就会变成非关键活动。

    ② AOE网的关键路径并不唯一,即关键路径可能有多条。且对于有几条关键路径的网,只提高一条关键路径上的关键活动并不能缩短整个工程的工期,只有加快那些包括在所有关键路径上的关键活动才能达到缩短工期的目的。

     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     

    ☘️

    展开全文
  • 关键路径 关键路径是求「工程上时间最短的问题」的方法 阅读本文前请先了解 拓扑排序 拓扑排序主要解决「工程是否能顺序进行」的问题,关键路径在拓扑排序的基础上解决「工程最短时间的问题」。 一、工程最短时间 ...

    关键路径

    关键路径是求「工程上时间最短的问题」的方法

    阅读本文前请先了解

    拓扑排序

    拓扑排序主要解决「工程是否能顺序进行」的问题,关键路径在拓扑排序的基础上解决「工程最短时间的问题」。

    一、工程最短时间

    image-20201231135025743

    工程时间最短的问题:

    按照工厂上图生产一辆汽车,外壳、发动机、轮子和其他部件可以同时建造。

    (1)求组装完成最短需要多少时间?

    (2)如何缩短最短时间?

    答案:

    (1)

    因为所有部件可以同时建造,所以只要最长时间的「发动机」不建造完毕集中部件就无法进行。所以:「工程最短时间」就是通向汇点的和 最长的权重。(最长权重的路径也叫做「关键路径」)

    上图 开始 -> 发动机完成 -> 部件集中完成 -> 组装完成 就是最长权重,组装完成最短用时 6

    (2)

    关键路径性质:缩短关键路径上的时间就能缩短最短时间(但是缩短的同时关键路径会动态发生变化,比如发动机建造时间 <= 2 ,继续缩短发动机建造时间就没用了)

    二、AOE (Activity On Edge)网络

    找出最长权重的路径就是关键路径。所以边必须有权重。(没权重咋算??)

    我们要在「拓扑排序」AOV 网的基础上介绍 AOE 网,区别如下

    • AOV(Activity On Vertex):活动在顶点上,边没有权重
    • AOE(Activity On Edge):活动在边上,边有权重

    定义如下:

    • 边(Edge)称之为「活动」(比如造轮子)

    • 顶点(Vertex)称之为「事件」(比如说轮子完成)

    image-20201231135025743

    三、关键路基算法

    3.1 关键路径算法原理

    我们如何求出关键路径?

    我们举个例子:

    小明有 2 个小时的作业,回家一共有 4 个小时做作业的时间。他可以选择一开始就做,或者因为「ddl 综合征」最后 2 小时才开始做。此时「做作业最早的时间」和「做作业的最晚时间」是不等的。

    老师知道小明的情况后将小明的作业增加到了 4 个小时的量,小明做作业的时间还是 4 个小时。小明只能回家就开始做作业才能做完。此时「做作业最早的时间」和「做作业的最晚时间」是相等的。

    「做作业最早的时间」和「做作业的最晚时间」是相等的说明:如果做作业的时间延误,将会导致整个工期延误,做作业的时间缩短,整个工期的最短时间就会缩短。

    我们将「做作业」抽象为「活动」Activity,「作业完成」抽象为「事件」Event

    关键路径定义:活动的最早发生时间和最晚发生时间相等的路径就是关键路径

    求关键路径我们只需要求出「活动最早发生时间」和「活动最晚发生时间」即可。


    3.2 关键路径算法

    (1)参数定义

    求关键路径我们只需要求出「活动最早发生时间」和「活动最晚发生时间」即可。

    但是在 AOE 图中,「活动」就是向量边,求向量边一般是困难的,我们可以借助顶点来求边。

    参数定义如下:

    • etv(Earliest Time of Vertex):顶点最早发生时间,也就是「事件最早发生时间」
    • ltv(Lastest Time of Vertex):顶点最晚发生时间,也就是「事件最晚发生时间」
    • ete(Earliest Time of Edge):边最早发生时间,也就是「活动最早发生时间」
    • lte(Lastest Time of Edge):边最晚发生时间,也就是「活动最晚发生时间」

    我们通过 etv 求 ete,ltv 求 lte


    (2)算法步骤

    步骤如下:(结合代码理解)

    • 通过拓扑排序求出 etv「事件最早发生时间」

      e t v [ j ] = m a x { e t v ( i ) + w e i g h t < i , j > } etv[j] = max\{etv(i) + weight<i,j>\} etv[j]=max{etv(i)+weight<i,j>}

    • 通过「反向推导」求出 ltv「事件最晚发生时间」

      l t v [ i ] = m a x { e t v ( j ) − w e i g h t < i , j > } ltv[i] = max\{etv(j) - weight<i,j>\} ltv[i]=max{etv(j)weight<i,j>}

    • 通过 etv 求出 ete「活动最早发生时间」

      活动最早发生时间等于 f r o m from from(箭头开始方向的事件最早发动时间)

    • 通过 ltv 求出 lte「活动最晚发生时间」

      活动最晚发生时间等于 t o − w e i g h t to - weight toweight(箭头结束方向的事件发生时间 - 权重)

    • 通过 lte - ete 求出关键路径


    四、代码

    示例如下图:

    image-20201231150824801

    public class CriticalPath {
        /** 边 */
        static class Edge{
            /** 权重 */
            int weight;
            /** 出度指向的点 */
            int toVertex;
            Edge next;
            public Edge(int weight, int toVertex, Edge next) {
                this.weight = weight;
                this.toVertex = toVertex;
                this.next = next;
            }
        }
        /** 顶点 */
        static class Vertex{
            /** 入度 数量 */
            int inNumber;
            /** 顶点信息 */
           Integer data;
            /** 第一条边 */
            Edge firstEdge;
            public Vertex(int inNumber, Integer data, Edge firstEdge) {
                this.inNumber = inNumber;
                this.data = data;
                this.firstEdge = firstEdge;
            }
        }
        static void criticalPath(List<Vertex> graph){
            //顶点数量
            int length = graph.size();
            //边数量
            int numOfEdges = 0;
            for (Vertex vertex : graph) {
                Edge edge = vertex.firstEdge;
                while (edge!=null){
                    numOfEdges ++;
                    edge = edge.next;
                }
            }
            //事件最早发生时间
            int[] etv = new int[length];
            //事件最晚发生时间
            int[] ltv = new int[length];
            //活动最早发生时间
            int[] ete = new int[numOfEdges];
            //活动最晚发生时间
            int[] lte = new int[numOfEdges];
            //1. 通过拓扑排序求 etv 「事件最早发生时间」
            //etvStack 用于储存拓扑排序后的顺序
            Stack<Vertex> etvStack = new Stack<>();
            //stack 用于拓扑排序
            Stack<Vertex> stack = new Stack<>();
            for (Vertex vertex : graph) {
                if (vertex.inNumber == 0){
                    stack.push(vertex);
                }
            }
            while (!stack.isEmpty()){
                Vertex pop = stack.pop();
                //储存拓扑排序后的结构
                etvStack.push(pop);
                //遍历出度
                Edge edge = pop.firstEdge;
                while (edge != null){
                    Vertex vertex = graph.get(edge.toVertex);
                    vertex.inNumber --;
                    if (vertex.inNumber == 0){
                        stack.push(vertex);
                    }
                    //赋值更大的距离给 etv
                    if (etv[pop.data] + edge.weight > etv[edge.toVertex]){
                        etv[edge.toVertex] = etv[pop.data] + edge.weight;
                    }
                    edge = edge.next;
                }
            }
            //2.通过 etv 反向推导求出 ltv「事件最晚发生时间」
            System.out.println("====etv====");
            for (int i = 0; i < etv.length; i++) {
                System.out.print("V"+i +" = "+etv[i]+" ");
            }
            System.out.println();
    
            //初始化 ltv
            Integer endVertex = etvStack.peek().data;
            for (int i = 0; i < ltv.length; i++) {
                ltv[i] = etv[endVertex];
            }
            while (!etvStack.isEmpty()) {
                Vertex pop = etvStack.pop();
                Edge edge = pop.firstEdge;
                while (edge != null) {
                    //赋值更小的距离给 ltv
                    if (ltv[pop.data] > ltv[edge.toVertex] - edge.weight) {
                        ltv[pop.data] = ltv[edge.toVertex] - edge.weight;
                    }
                    edge = edge.next;
                }
            }
            System.out.println("====ltv====");
            for (int i = 0; i < ltv.length; i++) {
                System.out.print("V"+i +" = "+ltv[i]+" ");
            }
            System.out.println();
            //3. 通过 etv 求 ete
            int index = 0;
            for (Vertex vertex : graph) {
                Edge edge = vertex.firstEdge;
                while (edge != null){
                    ete[index++] = etv[vertex.data];
                    edge = edge.next;
                }
            }
            System.out.println("====ete====");
            for (int i = 0; i < ete.length; i++) {
                System.out.print("E"+i +" = "+ete[i]+" ");
            }
            System.out.println();
            //4. 通过 ltv 求 lte
            index = 0;
            for (Vertex vertex : graph) {
                Edge edge = vertex.firstEdge;
                while (edge != null){
                    lte[index++] = ltv[edge.toVertex] - edge.weight;
                    edge = edge.next;
                }
            }
            System.out.println("====lte====");
            for (int i = 0; i < lte.length; i++) {
                System.out.print("E"+i +" = "+lte[i]+" ");
            }
            System.out.println();
            //5. 用 lte - ete 求关键路径 
            System.out.println("====关键路径====");
            for (int i = 0; i < ete.length; i++) {
                if (lte[i] - ete[i] == 0) {
                    System.out.print("E"+i+" ");
                }
            }
            return ;
        }
    
        /** 测试 */
        public static void main(String[] args) {
            char[] vertices = new char[]{'A','B','C','D','E','F','G'};
            Edge e3 = new Edge(2, 4, null);
            Edge e2 = new Edge(1, 3, e3);
            Edge e1 = new Edge(3, 2, e2);
            Edge e0 = new Edge(2, 1, e1);
            Edge e4 = new Edge(1, 5, null);
            Edge e5 = new Edge(1, 5, null);
            Edge e6 = new Edge(1, 5, null);
            Edge e7 = new Edge(1, 5, null);
            Edge e8 = new Edge(2, 6, null);
            Vertex a = new Vertex(0, 0, e0);
            Vertex b = new Vertex(1, 1, e4);
            Vertex c = new Vertex(1, 2, e5);
            Vertex d = new Vertex(1, 3, e6);
            Vertex e = new Vertex(1, 4, e7);
            Vertex f = new Vertex(4, 5, e8);
            Vertex g = new Vertex(1, 6, null);
            ArrayList<Vertex> graph = new ArrayList<>();
            graph.add(a);
            graph.add(b);
            graph.add(c);
            graph.add(d);
            graph.add(e);
            graph.add(f);
            graph.add(g);
            criticalPath(graph);
        }
    }
    

    结果:

    ====etv====
    V0 = 0 V1 = 2 V2 = 3 V3 = 1 V4 = 2 V5 = 4 V6 = 6 
    ====ltv====
    V0 = 0 V1 = 3 V2 = 3 V3 = 3 V4 = 3 V5 = 4 V6 = 6 
    ====ete====
    E0 = 0 E1 = 0 E2 = 0 E3 = 0 E4 = 2 E5 = 3 E6 = 1 E7 = 2 E8 = 4 
    ====lte====
    E0 = 1 E1 = 0 E2 = 2 E3 = 1 E4 = 3 E5 = 3 E6 = 3 E7 = 3 E8 = 4 
    ====关键路径====
    E1 E5 E8 
    
    展开全文
  • 数据结构,一门数据处理的艺术,精巧的结构在一个又一个算法下发挥着他们无与伦比的高效和精密之美,在为信息技术打下坚实地基的同时,也令无数开发者和探索者为之着迷。 也因如此,它作为博主大二上学期最重要的...
  • 参考书籍:数据结构(C语言版)严蔚敏吴伟民编著清华大学出版社 ... 1.关键路径 对整个工程和系统,人们关心的是两个方面的问题: 1)工程能否顺利进行 对AOV进行拓扑排序 ... 对AOE网关键路径 ...
  • 数据结构 图-关键路径AOE网络

    千次阅读 2020-07-25 22:10:08
    整个AOE网络可以说是一个人从V1(源点)走到V5(汇点)的活动过程,而这个人从V1走到V5所花费的最长时间的路径是从V1到V5的最长路径关键活动:能够影响整个工程完成时间的弧,即最长路径中的某一段路径(边)。如...
  • 认识AOE网  有向图中,用顶点表示活动,用有向边表示活动之间开始的先后顺序,则称这种有向图为AOV网络;AOV网络可以反应任务完成的先后顺序(拓扑排序)。  在AOV的边上加上权值表示完成该活动所需的时间,则...
  • 数据结构AOE网

    千次阅读 2020-06-21 14:40:00
    AOE 网数据结构 AOE 一、目的与要求 1)掌握AOE网的邻接表存储结构表示及创建算法的c语言实现; 2)理解AOE网的拓扑排序算法(算法7.12)的实现原理及应用; 3)掌握AOE网关键路径的计算算法(算法7.13,7.14...
  • :在AOE网中,从始点到终点具有最大路径长度(该路径上的各个活动所持续的时间之和)的路径称为关键路径。 关键活动 :关键路径上的活动称为关键活动。 事件发生最早时间v[k] 事件发生的最早时间可以表示为从...
  • 邻接矩阵、邻接表中任选一种作为图的存储结构AOE网关键路径算法,实现从AOE网源点到汇点的关键路径(2学时) 三、算法思路分析 四、算法反思 五、代码实现 #include<stdio.h> #include<stdlib.h> #...
  • AOE算法求解关键路径 问题描述: 输入顶点和边,得到有向图,求出关键路径。 . 关键路径通常(但并非总是)是决定项目工期的进度活动序列。它是项目中最长的路径,即使很小浮动也可能直接影响整个项目的最早...
  • 本程序为用MFC做的可视化界面的程序 实现了求关键路径 的功能
  • AOE网关键路径 在一个表示工程的带权有向图中,用顶点表示事件,用有向边表示活动,边上的权值表示活动持续的时间,称这样的有向图为边表示活动的,简称 AOE网(activity on edge network)。AOE网中没有入边的...
  • 代码如下: #include <iostream> #include <stack> #include <string> using namespace std; const int N = 10010; using vnodeType = int; typedef struct Node { int adj;...//..
  • 数据结构 课程设计报告 课程题目关键路径 学 院 班 级 学 号 姓 名 指导教师 完成日期 目录 TOC \o "1-1" \h \z \u 一需求分析 3 二概要设计 4 三详细设计 5 四 调试分析 11 五 用户使用说明 12 六 测试结果 12 七 ...
  • 数据结构算法之关键路径

    千次阅读 2020-07-14 18:41:23
    首先要了解AOE网关键路径的基本概念 这里详细说明一下,AOE网和AOV的区别和联系: 联系:都代表的是有向无环图。 区别: 1.AOE网的边表示活动,边有权值,边一般代表的是活动持续时间,顶点表示事件,事件是图...
  • 数据结构AOE网 计算题专题:关键路径法(CPM) 需要注意的点: 最重要的点,以下图为例: 一个活动有多个入口,这是表示此活动必须在前置的多个入口都完成时,才能开始。 即,开始条件 = 入口1 && 入口2 ...
  • AOE网关键路径

    2021-01-03 11:00:28
    生活中往往有着这样的场景,我们想做一件事情,但是需要做其他的事情来达到这件事情,例如,学数据结构之前,首先需要学一门程序设计语言,还要学习离散数学,如果学语言需要耗费半年时间,学离散数学需要一年事件,...
  • 数据结构-关键路径

    2020-09-02 21:57:33
    关键路径AOE中,开始顶点到结束顶点的所有路径中,具有最大路径长度的路径成为关键路径,路径上的点是关键活动。 (1)关键路径如果有多条,至提高一条关键路径上的关键活动并不能缩短工期,必须要加快所有关键...
  • AOE网来估算某些工程的完成时间是非常有用的。 逆拓扑次序。 vl(n) = ve(n); vl(i) = MIN{vl(j)(事件最晚开始时间) - dut(<i, j>)(边权)}; 先进行一次拓扑排序 基于拓扑排序 下面代码的上一部分求事件的...
  • 关键路径 AOV相对应的是AOE(Activity On Edge) ,是边表示活动的有向无环图,如下图所示。图中顶点表示事件(Event),每个事件表示在其前的所有活动已经完成,其后的活动可以开始;弧表示活动,弧上的权值表示...
  • 1.问题描述 ...(1)对一个描述工程的AOE网,应判断其是否能够顺利进行。 (2)若该工程能顺利进行,输出完成整项工程至少需要多少时间,以及每一个关键活动所依附的两个顶点、最早发生时间、最迟发生时间。
  • 第7章 图7.1 图的定义和术语7.2 图的存储结构7.3 图的遍历7.4 图的连通性问题7.5 有向无环图及其应用 ...对AOV进行拓扑排序 2估算整个工程完成所必须的最短时间 对AOE网关键路径AOE-网AOE网(Activity On Edge Ne
  • AOE网关键路径
  • 数据结构之图的关键路径

    千次阅读 2018-11-06 11:18:43
    title: 数据结构之图的关键路径 tags: 数据结构与算法之美 一、AOE和AOV 1.AOE网 AOE-:指用边表示活动的,是一个带权的有向无环图,其中,顶点表示事件弧表示活动,权表示活动持续的时间,通常一个AOE-可...
  • AOE网络的关键路径问题

    千次阅读 2017-06-04 12:01:31
    关于AOE网络的基本概念可以参考《数据结构》或者search一下就能找到,这里不做赘述。寻找AOE网络的关键路径目的是:发现该活动网络中能够缩短工程时长的活动,缩短这些活动的时长,就可以缩短整个工程的时长。因此,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,948
精华内容 779
关键字:

数据结构aoe网关键路径

数据结构 订阅