图之查找关键路径（python）实现

与AOV-网对应的是AOE-网（Activity on Edge）即便表示活动的网。AOE网是一个带权的有向无环图，其中，顶点表示事件，弧表示活动持续的时间。通常，AOE网可以用来估算工程的完成时间。
由于AOE网中的有些活动是可以并行进行的，所以完成整个工程的最短时间是从开始点到完成点的最长路径长度（这里所说的路径长度是指路径上各活动的持续时间之和，不是路径上弧的数目。）路径长度最长的路径叫做关键路径。

求关键路径的算法：
（1）输入e条弧（j，k），建立AOE网；
（2）从源点$v_0$出发，令ve[0] = 0,按照拓扑排序求其余各个顶点的最早发生时间ve[i],(i <= i <= n-1)。如果得到的拓扑有序序列中顶点的个数小于网中的顶点数n，则说明网中存在环，不能求关键路径，算法终止；否则执行步骤三；
（3）从汇点$v_n$出发，令vl[n-1] = ve[n-1]，按照逆拓扑有序求其余各顶点的最迟发生时间vl[i],(n-2 >= i >= 2);
（4）根据各顶点的ve和vl值，求每条弧s的最早开始时间e(s)和最迟开始时间l(s)。若某条弧满足条件e(s) = l(s),则为关键活动。

那到底如何来求呢？我们来看看例子。

首先先解释下上面提到的结果名次词：
顶点表示事件（能被触发，最早发生时间Ve(j);最晚发生时间Vl(j)）;
边表示活动（能被开始，最早开始时间e(i)；最晚开始时间l(i)）

并且AOE网中的点和边遵循两个原则：
（1）只有某顶点所代表事件发生后，从该顶点出发的各活动才能开始
（2）只有进入某顶点的各活动都结束，该顶点所代表的事件才能发生

现在那知道了点和边的属性，怎样计算关键路径呢？
计算关键路径：

计算关键路径，只需求出上面的四个特征属性，然后取e(i)=l(i)的边即为关键路径上的边（关键路径可能不止一条）。

下面我们来计算一个例图的关键路径：

下面我们来计算各事件的：
Ve(v):最早发生时间：是指从始点开始到顶点Vk的最大路径长度
(1)从前向后，取大值：直接前驱结点的Ｖe(j)＋到达边（指向顶点的边）的权值，有多个值的取较大者
(2)首结点Ve(j)已知，为0

Vl(v):最迟发生时间:在不推迟整个工期的前提下，事件vk允许的最晚发生时间
(1)从后向前，取小值：直接后继结点的Ｖl(j) –发出边（从顶点发出的边）的权值，有多个值的取较小者;
(2)终结点Vl(j)已知，等于它的Ve(j)）

下面来计算各活动的：
e(v):最早发生时间：
若活动ai由弧<vk,vj>表示，则活动ai的最早开始时间应该等于事件vk的最早发生时间。因而，有：e[i]=ve[k];（即：边（活动）的最早开始时间等于，它的发出顶点的最早发生时间）

l(v):最迟发生时间：
若活动ai由弧<vk,vj>表示，则ai的最晚开始时间要保证事件vj的最迟发生时间不拖后。 因而有：l[i]=vl[j]-len<vk,vj>1（为边（活动）的到达顶点的最晚发生时间减去边的权值）

**d(v):活动时间余量：**d(v) = l(v) - e(v)

那么由上表可知：d(v)等于0的为关键活动，所以a1,a4,a7,a8,a10,a11所表示的活动为关键路径：

至此，我们得到了关键路径：A-B,B-E,E-F,E-G,F-I,G-I。

下面我们用代码来实现该过程：

def find_shorted_path():
    #顶点列表
    node_list = ['A','B','C','D','E','F','G','H','I']

    edge_list = [['A','B',  6],
                 ['A', 'C', 4],
                 ['A', 'D', 5],
                 ['B', 'E', 1],
                 ['C', 'E', 1],
                 ['D', 'H', 2],
                 ['E', 'F', 9],
                 ['E', 'G', 7],
                 ['F', 'I', 2],
                 ['G', 'I', 4],
                 ['H', 'I', 4],
                 ]
    '''计算各个顶点的Ve(v)最早发生时间'''

    #找出图的起点
    temp_start_list = []
    for edge in edge_list:
        temp_start_list.append(edge[1])
    start_node = [x for x in node_list if x not in temp_start_list]
    # print(start_node)

    Ve_node_dict = {}
    Ve_node_dict[start_node[0]] = 0

    for node in node_list:
        Ve_tempnode_list = []
        for edge in edge_list:
            if node == edge[1]:
                temp_Ve_node_value = Ve_node_dict[edge[0]] + edge[2]
                Ve_tempnode_list.append(temp_Ve_node_value)
        if len(Ve_tempnode_list) == 0:
            Ve_node_dict[node] = 0
        if len(Ve_tempnode_list) == 1:
            Ve_node_value = Ve_tempnode_list[0]
            Ve_node_dict[node] = Ve_node_value
        if len(Ve_tempnode_list) > 1:
            Ve_node_value = max(Ve_tempnode_list)
            Ve_node_dict[node] = Ve_node_value
    print('Ve(v)最早发生时间:\n',Ve_node_dict,'\n')

    '''计算各个顶点的Vl(v)最迟发生时间'''

    #找出图的终点
    temp_end_list = []
    for edge in edge_list:
        temp_end_list.append(edge[0])
    end_node = [x for x in node_list if x not in temp_end_list]
    # print(end_node)

    Vl_node_dict = {}
    Vl_node_dict[end_node[0]] = Ve_node_dict[end_node[0]]

    reverse_edge_list = []
    for i in range(len(edge_list)-1,-1,-1):
        reverse_edge_list.append(edge_list[i])


    for node in reversed(node_list):
        Vl_tempnode_list = []
        for edge in reverse_edge_list:
            if node == edge[0]:
                temp_Vl_node_value = Vl_node_dict[edge[1]] - edge[2]
                Vl_tempnode_list.append(temp_Vl_node_value)
        if len(Vl_tempnode_list) == 0:
            Vl_node_dict[node] = Ve_node_dict[end_node[0]]
        if len(Vl_tempnode_list) == 1:
            Vl_node_value = Vl_tempnode_list[0]
            Vl_node_dict[node] = Vl_node_value
        if len(Vl_tempnode_list) > 1:
            Vl_node_value = min(Vl_tempnode_list)
            Vl_node_dict[node] = Vl_node_value
    print('Vl(v)最迟发生时间:\n',Vl_node_dict,'\n')

    '''计算各个边的e(a)最早发生时间'''

    e_bian_dict = {}
    for edge in edge_list:
        e_bian_dict['{}-{}'.format(edge[0],edge[1])] = Ve_node_dict[edge[0]]
    print('e(a)最早发生时间:\n',e_bian_dict,'\n')

    '''计算各个边的l(a)最迟发生时间'''

    l_bian_dict = {}
    for edge in edge_list:
        l_bian_dict['{}-{}'.format(edge[0],edge[1])] = Vl_node_dict[edge[1]] - edge[2]
    print('l(a)最迟发生时间:\n',l_bian_dict,'\n')

    '''计算时间余量d(a)'''

    d_bian_dict = {}
    for bian in e_bian_dict.keys():
        d_bian_dict[bian] = l_bian_dict[bian] - e_bian_dict[bian]
    print("d(a)时间余量:\n",d_bian_dict,'\n')

    print("关键路径为：",[x for x in d_bian_dict if d_bian_dict[x] == 0])

if __name__ == "__main__":
    find_shorted_path()

运行结果：

Ve(v)最早发生时间:
 {'A': 0, 'B': 6, 'C': 4, 'D': 5, 'E': 7, 'F': 16, 'G': 14, 'H': 7, 'I': 18} 

Vl(v)最迟发生时间:
 {'I': 18, 'H': 14, 'G': 14, 'F': 16, 'E': 7, 'D': 12, 'C': 6, 'B': 6, 'A': 0} 

e(a)最早发生时间:
 {'A-B': 0, 'A-C': 0, 'A-D': 0, 'B-E': 6, 'C-E': 4, 'D-H': 5, 'E-F': 7, 'E-G': 7, 'F-I': 16, 'G-I': 14, 'H-I': 7} 

l(a)最迟发生时间:
 {'A-B': 0, 'A-C': 2, 'A-D': 7, 'B-E': 6, 'C-E': 6, 'D-H': 12, 'E-F': 7, 'E-G': 7, 'F-I': 16, 'G-I': 14, 'H-I': 14} 

d(a)时间余量:
 {'A-B': 0, 'A-C': 2, 'A-D': 7, 'B-E': 0, 'C-E': 2, 'D-H': 7, 'E-F': 0, 'E-G': 0, 'F-I': 0, 'G-I': 0, 'H-I': 7} 

关键路径为： ['A-B', 'B-E', 'E-F', 'E-G', 'F-I', 'G-I']

与手动查找的关键路径相同。

本文原创，转载请注明出处！！！