关键路径

1、拓扑排序的意义？

举个例子先：一个软件专业的学生学习一系列的课程，其中一些课程必须再学完它的基础的先修课程才能开始。如：在《程序设计基础》和《离散数学》学完之前就不能开始学习《数据结构》。这些先决条件定义了课程之间的领先(优先)关系。这个关系可以用有向图更清楚地表示。图中顶点表示课程，有向边表示先决条件。若课程i是课程j的先决条件，则图中有弧<i,j>。若要对这个图中的顶点所表示的课程进行拓扑排序的话，那么排序后得到的序列，必须是按照先后关系进行排序，具有领先关系的课程必然排在以它为基础的课程之前，若上例中的《程序设计基础》和《离散数学》必须排在《数据结构》之前。进行了拓扑排序之后的序列，称之为拓扑序列。

2、关键路径的定义：

路径上各个活动所持续的时间之和称为路径长度，从源点到汇点具有最大长度的路径叫关键路径。

3、如何实现关键路径？

辨别关键活动就是要找e(i)=l(i)的活动。为了求得e(i)和l(i)，首先应求得事件的最早发生时间ve(j)和最迟发生时间vl(j)。如果活动ai由弧<j,k>表示，其持续时间记为dut(<j,k>)，则有如下关系
e(i) = ve(j)
l(i) = vl(k) - dut(<j,k>)
求解ve(j)和vl(j)需分两个步进行：
1） 从ve(0)=0开始向前推进求得ve(j)
Ve(j) = Max{ve(i) + dut(<i,j>) };<i,j>属于T，j=1,2...,n-1
其中T是所有以第j个顶点为头的弧的集合。

2） 从vl(n-1) = ve(n-1)起向后推进求得vl(j)
vl(i) = Min{vl(j) - dut(<i,j>};<i,j>属于S，i=n-2,...,0
其中，S是所有以第i个顶点为尾的弧的集合。
这两个递推公式的计算必须分别在拓扑有序和逆拓扑有序的前提先进行。也就是说，ve(j-1)必须在vj的所有前驱的最早发生时间求得之后才能确定，而vl(j-1)必须在Vj的所有后继的最迟发生时间求得之后才能确定。因此可以在拓扑排序的基础上计算ve(j-1)和vl(j-1)。

4、关键路径算法

首先定义全局变量：

其中stack2用来存储拓扑排序列，已便后面求关键路径时使用。

上述代码周浩，除了加粗部分外，与前面的的拓扑排序算法没有什么不同的。

下面来看关键路径的算法代码。

1、第6行，调用求拓扑序列的函数，求出etv，和栈stack的值如下，

2、当程序执行到第20行时，etv[1]=3,ltv[1]=7,表示v1这件事在第7天才开始，也可以保证整个工程的按期完成，v1也可以提前开始，但最早也只能在第3天开始。

3、所以就是判断ete与lte是否相等，相等意味着活动没有任何空闲，是关键活动时间，否则就不是，最后的关键路径如下。

个人总结：

最长的一条路径就是关键路径,因为图中每个活动都是必须的，只有最长的工期完成后，项目才真正完成了，图中4+8+3+4+5+3=27 也就是v0-v2-v3-v4-v7-v8-v9 ，显然是最长的，所以为关键路径。

从左边开始每个活动所需要最长的时间就是最早开始时间，如v1，只有v0指向它，那么最早开始时间就是3；相对于v3，v0->v2->v3
4+8=12，v0->v1->v3 3+5+8,两者比较，前者大，故12为最早开始时间，依次类推。

从右边倒推，可以求的最迟开始时间，如v9为27，以v8为例，v8->v9 倒推 27-3=24 所以I最迟开始时间为24；v4为例，v4->v7->v8->v9 倒推27-3-5-415=39，v4->v6->v9 倒推 27-2-9=16，两者取最小的，所以v4的最迟开始时间为15。

代码设计：

1、在结点的定义中增加ee和le 字段用于记录个事件的最早开始时间和最迟开始时间，同时得到关键路径和最小工期

2、邻接矩阵中使用边权代替原来连接标志1

3、进行拓扑排序，形成拓扑序列

1 2 3 4 5 6 7 8 9

4、按拓扑序列顺序，从前向后搜索寻找个活动（即边），若存在该活动，则计算相应事件的最早开始时间。

5、按拓扑序列顺序，从后向前搜索寻找个活动（即边），若存在该活动，则计算相应事件的最迟开始时间。

6、计算各活动的最早开始时间和最迟开始时间

[cpp]  view plain  copy

1. #include <stdio.h>    
2. #include <stdlib.h>    
3. #define MaxVerNum 20    
4.      
5. int visited[MaxVerNum];    
6.      
7. typedef char VertexType;    
8.      
9. typedef struct ArcNode    
10. {    
11.        int adjvex;                                         //该弧指向的顶点位置    
12.        struct ArcNode * nextarc;          //指向下一个表结点    
13.        int info;                                      //权值信息    
14. }ArcNode;                                              //边结点类型    
15.      
16. typedef struct VNode    
17. {    
18.        VertexType data;    
19.        int indegree;    
20.        ArcNode * firstarc;    
21. }VNode, Adjlist[MaxVerNum];    
22.      
23. typedef struct    
24. {    
25.        Adjlist vertices;            //邻接表    
26.        int vernum, arcnum;             //顶点数和弧数    
27. }ALGraph;    
28.      
29. //查找符合的数据在数组中的下标    
30. int LocateVer(ALGraph G, char u)    
31. {    
32.        int i;    
33.        for(i = 0; i < G.vernum; i++)    
34.        {    
35.               if(u == G.vertices[i].data)    
36.                      return i;    
37.        }    
38.        if(i == G.vernum)    
39.        {    
40.               printf("Error u!\n");    
41.               exit(1);    
42.        }    
43.        return 0;    
44. }    
45.      
46. //常见图的邻接矩阵    
47. void CreateALGraph(ALGraph &G)    
48. {    
49.        int i, j, k, w;    
50.        char v1, v2;    
51.        ArcNode * p;    
52.        printf("输入顶点数和弧数: ");    
53.        scanf("%d %d", &G.vernum, &G.arcnum);    
54.        printf("请输入顶点!\n");    
55.        for(i = 0; i < G.vernum; i++)    
56.        {    
57.               printf("请输入第 %d 个顶点: \n", i);    
58.               fflush(stdin);    
59.               scanf("%c", &G.vertices[i].data);    
60.               G.vertices[i].firstarc = NULL;    
61.               G.vertices[i].indegree = 0;    
62.        }    
63.      
64.        for(k = 0; k < G.arcnum; k++)    
65.        {    
66.               printf("请输入弧的顶点和相应权值(v1, v2, w): \n");    
67.               //清空输入缓冲区    
68.               fflush(stdin);    
69.               scanf("%c %c %d", &v1, &v2, &w);    
70.               i = LocateVer(G, v1);    
71.               j = LocateVer(G, v2);    
72.               p = (ArcNode *)malloc(sizeof(ArcNode));    
73.               p->adjvex = j;    
74.               p->info = w;    
75.               p->nextarc = G.vertices[i].firstarc;    
76.               G.vertices[i].firstarc = p;    
77.               G.vertices[j].indegree++;                   //vi->vj, vj入度加1    
78.        }    
79.        return;    
80. }    
81.      
82. //求图的关键路径函数    
83. void CriticalPath(ALGraph G)    
84. {    
85.        int i, k, e, l;    
86.        int * Ve, * Vl;    
87.        ArcNode * p;    
88.      
89.        //*****************************************    
90.        //以下是求时间最早发生时间    
91.        //*****************************************    
92.      
93.        Ve = new int [G.vernum];    
94.        Vl = new int [G.vernum];    
95.      
96.        for(i = 0; i < G.vernum; i++)              //前推    
97.               Ve[i] = 0;    
98.      
99.        for(i = 0; i < G.vernum; i++)    
100.        {    
101.               ArcNode * p = G.vertices[i].firstarc;    
102.               while(p != NULL)    
103.               {    
104.                      k = p->adjvex;    
105.                      if(Ve[i] + p->info > Ve[k])    
106.                             Ve[k] = Ve[i]+p->info;    
107.                      p = p->nextarc;    
108.               }    
109.        }    
110.        //*****************************************    
111.        //以下是求最迟发生时间    
112.        //*****************************************    
113.        for(i = 0; i < G.vernum; i++)    
114.               Vl[i] = Ve[G.vernum-1];    
115.        for(i = G.vernum-2; i >= 0; i--)                 //后推    
116.        {    
117.               p = G.vertices[i].firstarc;    
118.               while(p != NULL)    
119.               {    
120.                      k = p->adjvex;    
121.                      if(Vl[k] - p->info < Vl[i])    
122.                             Vl[i] = Vl[k] - p->info;    
123.                      p = p->nextarc;    
124.               }    
125.        }    
126.        //******************************************    
127.        for(i = 0; i < G.vernum; i++)    
128.        {    
129.               p = G.vertices[i].firstarc;    
130.               while(p != NULL)    
131.               {    
132.                      k = p->adjvex;    
133.                      e = Ve[i];              //最早开始时间为时间vi的最早发生时间    
134.                      l = Vl[k] - p->info;             //最迟开始时间    
135.                      char tag = (e == l) ? '*' : ' '; //关键活动    
136.                      printf("(%c, %c), e = %2d, l = %2d, %c\n", G.vertices[i].data, G.vertices[k].data, e, l, tag);    
137.                      p = p->nextarc;    
138.               }    
139.        }    
140.        delete [] Ve;    
141.        delete [] Vl;    
142. }    
143.      
144. void main()    
145. {    
146.        ALGraph G;    
147.        printf("以下是查找图的关键路径的程序。\n");    
148.        CreateALGraph(G);    
149.        CriticalPath(G);    
150. }    
151. 转载自https://blog.csdn.net/tuwenqi2013/article/details/52795710