精华内容
下载资源
问答
  • 由于AOE网中的某些活动能够同时进行,故完成整个工程所必须花费的时间应该为始点到终点的最大路径长度。关键路径长度是整个工程所需的最短工期。
  • 数据结构中的关键路径实现,可视化界面,迪杰斯特拉算法,和弗洛伊德算法
  • 前面我们已经了解到了无环有向图怎样求关键路径的方法,今天我们来看看无向图怎样求最短路径,这在实际应用过程中的作用很大,不如交通路线图,从出发点到终点,走哪条路用时最短,或者花费最少等问题。 我们先来看...

    前面我们已经了解到了无环有向图怎样求关键路径的方法,今天我们来看看无向图怎样求最短路径,这在实际应用过程中的作用很大,不如交通路线图,从出发点到终点,走哪条路用时最短,或者花费最少等问题。

    我们先来看单源最短路径的求法。即给定了起点vv,求从起点出发,到图中各个顶点的最短路径问题。
    对于这个问题,迪杰斯特拉(Dijkstra)提出了一个按路径长度递增的次序产生的最短路径的算法。

    下面介绍迪杰斯特拉算法思想:
    (1)、假设用带权的邻接矩阵arcs来表示带权有向图,arcs[i][j]表示弧<viv_i,vjv_j>上的权值。若<viv_i,vjv_j>不存在,则置arcs[i][j]为无穷大(在计算机中可用允许的最大值代替。)S为已经找到的从vv出发的最短路径的终点的集合,他的初始状态为空集。那么,从v出发到图中的其余各顶点(终点)viv_i可能达到的最短路径长度的初值为:
    D[i] = arcs[ Locate Vex(G,v) ][i] viv_i 属于 V
    (2)、选择vjv_j,使得:D[j] = Min{D[i] | viv_i 属于 V-S},vjv_j就是当前求得的一条从v出发的最短路径的终点。令:S = S 并 {j}
    (3)、修改从v出发到集合V-S上任意一点vkv_k可达的最短路径长度。如果:D[j] + arcs[k][k] < D[k],则修改D[k]为:D[k]= D[j] + arcs[j][k]
    (4)、重复操作(2)、(3)共n-1次。由此求得从v到图上其余各顶点的最短路径是依据路径长度递增的序列。

    太复杂了,我们来总结描述下:
    迪杰斯特拉算法:
    假设存在G=<V,E>,源顶点为V0,S={V0},distance[i] 记录V0到i的最短距离,matrix[i][j]记录从i到j的边的权值,即两点之间的距离。
    1)从V-S中选择使dist[i]值最小的顶点i,将i加入到U中;
    2)更新与i直接相邻顶点的dist值。dist[j]=min{dist[j],dist[i]+matrix[i][j]}
    3)直到S=V,所有顶点都包含进来了,算法停止。

    Dijkstra算法主要针对的是有向图的单源最短路径问题,且不能出现权值为负的情况!Dijkstra算法类似于贪心算法,其应用根本在于最短路径的最优子结构性质。

    最短路径的最优子结构性质:
    如果P(i,j)={Vi…Vk…Vs…Vj}是从顶点i到j的最短路径,k和s是这条路径上的一个中间顶点,那么P(k,s)必定是从k到s的最短路径。

    根据其算法思想,确立操作步骤如下:
    (1) 初始时,S只包含起点s;U包含除s外的其他顶点,且U中顶点的距离为"起点s到该顶点的距离"[例如,U中顶点v的距离为(s,v)的长度,然后s和v不相邻,则v的距离为∞]。
    (2) 从U中选出"距离最短的顶点k",并将顶点k加入到S中;同时,从U中移除顶点k。
    (3) 更新U中各个顶点到起点s的距离。之所以更新U中顶点的距离,是由于上一步中确定了k是求出最短路径的顶点,从而可以利用k来更新其它顶点的距离;例如,(s,v)的距离可能大于(s,k)+(k,v)的距离。
    (4) 重复步骤(2)和(3),直到遍历完所有顶点。

    下面我们用列表法来手动实现这个过程:
    我们以下图为例:起点为A
    在这里插入图片描述
    1、找到起始点A,找出从A到图中各点的路径长度:A的邻接点未B和D,其余点距离都为inf(无穷大)
    在这里插入图片描述

    次数/编号 B C D E F
    1 1 max 2 max max

    2、找到最小值是从A到B的距离1,接下来以B为起始点,找到B的邻接点D,C,E:
    在这里插入图片描述

    次数/编号 B C D E F
    1 1 inf 2 inf inf
    2 【1】 min{1+2,inf}=3 min{1+4,2}=2 min{1+3,inf}=4 inf

    3、找到第二次最小值为从A到D的距离2,以D为起始点:
    在这里插入图片描述

    次数/编号 B C D E F
    1 1 inf 2 inf inf
    2 【1】 min{1+2,inf}=3 min{1+4,2}=2 min{1+3,inf}=4 inf
    3 【1】 3 【2】 min{2+6,4,inf}=4 inf

    4、找到第三次的最小值从A到C的值3,以C为起始点:
    在这里插入图片描述

    次数/编号 B C D E F
    1 1 inf 2 inf inf
    2 【1】 min{1+2,inf}=3 min{1+4,2}=2 min{1+3,inf}=4 inf
    3 【1】 3 【2】 min{2+6,4,inf}=4 inf
    4 【1】 【3】 【2】 min{3+1,4,inf}=4 min{3+4,inf}=7

    5、找到第4次最小值是从A到E的值4,以E为起始点:
    在这里插入图片描述

    次数/编号 B C D E F
    1 1 inf 2 inf inf
    2 【1】 min{1+2,inf}=3 min{1+4,2}=2 min{1+3,inf}=4 inf
    3 【1】 3 【2】 min{2+6,4,inf}=4 inf
    4 【1】 【3】 【2】 min{3+1,4,inf}=4 min{3+4,inf}=7
    5 【1】 【3】 【2】 【4】 min{4+2,7,inf} =6

    至此所有的顶点全部遍历完成:
    在这里插入图片描述

    次数/编号 B C D E F
    1 1 inf 2 inf inf
    2 【1】 min{1+2,inf}=3 min{1+4,2}=2 min{1+3,inf}=4 inf
    3 【1】 3 【2】 min{2+6,4,inf}=4 inf
    4 【1】 【3】 【2】 min{3+1,4,inf}=4 min{3+4,inf}=7
    5 【1】 【3】 【2】 【4】 【6】

    那么从表中我们就能够得到:
    A到B,到C,到D,到E,到F的最短路径依次为1,3,2,4,6

    现在我们得到了从A到各个节点的最短路径的值,那么问题来了,怎样得到最短路径呢?

    例如,现在我们要求出从A到F的最短路径:
    我们使用上一跳存储列表法来实现,初始化都为-1,-1表示直连。

    名称/编号 B C D E F
    cost 1 3 2 4 6
    last—top -1 -1 -1 -1 -1

    1、首先是顶点B,因为B和A直连,所以,直接赋值为-1

    名称/编号 B C D E F
    cost 1 3 2 4 6
    last—top 【-1】 -1 -1 -1 -1

    2、接下来是顶点C,A要到达顶点C,距离为3,必须经过顶点B,所以C的上一跳为B

    名称/编号 B C D E F
    cost 1 3 2 4 6
    last—top 【-1】 B -1 -1 -1

    3、接下来是点D,D和A直连,直接赋值为-1

    名称/编号 B C D E F
    cost 1 3 2 4 6
    last—top 【-1】 B 【-1】 -1 -1

    4、接下来是点E,A要到达E,距离为4,必须经过顶点B,所以E的上一跳为B

    名称/编号 B C D E F
    cost 1 3 2 4 6
    last—top 【-1】 B 【-1】 B -1

    5、接下来是点F,A要到达顶点F,距离为6,必须经过顶点E,所以F的上一跳为E

    名称/编号 B C D E F
    cost 1 3 2 4 6
    last—top 【-1】 B 【-1】 B E

    那么现在我们要从A到F,最短路径是什么呢?
    过程是这样的要到F,得经过E;要到E,得经过B;要到B,得经过A。
    于是,从A到F的最短路径为:A —> B —> E —> F

    def Dijkstra(network, s, d):  # 迪杰斯特拉算法算s-d的最短路径,并返回该路径和值
        print("Start Dijstra Path……")
        path = []  # 用来存储s-d的最短路径
        n = len(network)  # 邻接矩阵维度,即节点个数
        fmax = float('inf')
        w = [[0 for _ in range(n)] for j in range(n)]  # 邻接矩阵转化成维度矩阵,即0→max
    
        book = [0 for _ in range(n)]  # 是否已经是最小的标记列表
        dis = [fmax for i in range(n)]  # s到其他节点的最小距离
        book[s - 1] = 1  # 节点编号从1开始,列表序号从0开始
        midpath = [-1 for i in range(n)]  # 上一跳列表
        for i in range(n):
          for j in range(n):
            if network[i][j] != 0:
              w[i][j] = network[i][j]  # 0→max
            else:
              w[i][j] = fmax
            if i == s - 1 and network[i][j] != 0:  # 直连的节点最小距离就是network[i][j]
              dis[j] = network[i][j]
        for i in range(n - 1):  # n-1次遍历,除了s节点
          min = fmax
          for j in range(n):
            if book[j] == 0 and dis[j] < min:  # 如果未遍历且距离最小
              min = dis[j]
              u = j
          book[u] = 1
          for v in range(n):  # u直连的节点遍历一遍
            if dis[v] > dis[u] + w[u][v]:
              dis[v] = dis[u] + w[u][v]
              midpath[v] = u + 1  # 上一跳更新
        j = d - 1  # j是序号
        path.append(d)  # 因为存储的是上一跳,所以先加入目的节点d,最后倒置
        while (midpath[j] != -1):
          path.append(midpath[j])
          j = midpath[j] - 1
        path.append(s)
        path.reverse()  # 倒置列表
        print("path:",path)
        # print(midpath)
        print("dis:",dis)
        # return path
    
    network = [[0, 1, 0, 2, 0, 0],
               [1, 0, 2, 4, 3, 0],
               [0, 2, 0, 0, 1, 4],
               [2, 4, 0, 0, 6, 0],
               [0, 3, 1, 6, 0, 2],
               [0, 0, 4, 0, 2, 0]]
    Dijkstra(network, 1, 6)
    

    运行结果:

    Start Dijstra Path……
    path: [1, 2, 5, 6]
    dis: [2, 1, 3, 2, 4, 6]
    
    展开全文
  • 总结最短路径算法关键先把已知最短路径顶点集...集中在加入时可以记录每个顶点的最短路径也可以在加入完毕 后回溯找到每个顶点的最短路径和权重 迪杰斯特拉算法用于求解一个有向图也 可以是无向图无向图是有向图的一种
  • 我感觉这个和prim还是有点相似之处的,关键这里多了一个记录上次最短路径的和p,光看代码没用,要知道思想 #include <stdio.h> #define MAX_SIZE 55 #define INF 0xFFFFFF int G[MAX_SIZE][MAX_SIZE]; int vis...

    题目就不多说了,
    可以用这个算法演示一遍,Dijkstra
    我感觉这个和prim还是有点相似之处的,关键这里多了一个记录上次最短路径的和p,光看代码没用,要知道思想

    #include <stdio.h>
    #define MAX_SIZE 55
    #define INF 0xFFFFFF
    int G[MAX_SIZE][MAX_SIZE];
    int vis[MAX_SIZE];
    int num[MAX_SIZE];
    int n,m;
    void Dijkstra()
    {
    	for(int i = 0;i < n;i++){
    		if(G[m][i] != 0) num[i] = G[m][i];
    		else num[i] = INF;
    	}
    	vis[m] = 1;	
    	num[m] = 0;
    	int p = 0;
    	
    	for(int j = 1;j < n;j++){
    		int k,t = INF;
    		for(int i = 0;i < n;i++){
    			if(vis[i] == 0 && num[i] < t){
    				t = num[i];
    				k = i;
    			}
    		}
    		vis[k] = 1;
    		p = num[k];
    		for(int i = 0;i < n;i++){
    			if(G[k][i] != 0){
    				if(p+G[k][i] < num[i]){
    					num[i] = p+G[k][i];
    				}
    			}
    		}
    	}
    	return;
    }
    int main()
    {
    	scanf("%d %d",&n,&m);
    	for(int i = 0;i < n;i++){
    		for(int j = 0;j < n;j++){
    			scanf("%d",&G[i][j]);
    		}
    	}
    	Dijkstra();
    	for(int i = 0;i < n;i++){
    		if(i != m) {
    			if(num[i] < INF) printf("%d ",num[i]);
    			else printf("%d ",-1);
    		}
    	}
    	return 0;
    }
    
    展开全文
  • 迪杰斯特拉算法是一种用于求解最短路径的算法,关键在于每一次循环均能确定下一个永久标号点,从而方便求解最短路径。 教程传送门:https://www.bilibili.com/video/av33533137/?p=23 按路径长度递增次序产生算法...

    迪杰斯特拉算法是一种用于求解最短路径的算法,关键在于每一次循环均能确定下一个永久标号点,从而方便求解最短路径。

    教程传送门:https://www.bilibili.com/video/av33533137/?p=23

    按路径长度递增次序产生算法:

    把顶点集合V分成两组:

    (1)S:已求出的顶点的集合(初始时只含有源点V0)

    (2)V-S=T:尚未确定的顶点集合

    将T中顶点按递增的次序加入到S中,保证:

    (1)从源点V0到S中其他各顶点的长度都不大于从V0到T中任何顶点的最短路径长度

    (2)每个顶点对应一个距离值

    S中顶点:从V0到此顶点的长度

    T中顶点:从V0到此顶点的只包括S中顶点作中间顶点的最短路径长度

    依据:可以证明V0到T中顶点Vk的,或是从V0到Vk的直接路径的权值;或是从V0经S中顶点到Vk的路径权值之和

    反证法可证)

    求最短路径步骤

    算法步骤如下:

    G={V,E}

    1. 初始时令 S={V0},T=V-S={其余顶点},T中顶点对应的距离值

    若存在<V0,Vi>,d(V0,Vi)为<V0,Vi>弧上的权值

    若不存在<V0,Vi>,d(V0,Vi)为∞

    2. 从T中选取一个与S中顶点有关联边且权值最小的顶点W,加入到S中

    3. 对其余T中顶点的距离值进行修改:若加进W作中间顶点,从V0到Vi的距离值缩短,则修改此距离值

    重复上述步骤2、3,直到S中包含所有顶点,即W=Vi为止

     

     

    展开全文
  • 在图的应用中,有一个很重要的需求:我们需要知道从某一个点开始,到其他所有点的最短路径。...它的关键思想是以起始点为中心,向外一层层扩散,直到扩展到终点为止。Dijkstra算法能够得出最短路径

    原文:http://www.cnblogs.com/sadgeminids/archive/2011/12/29/2306719.html


    在图的应用中,有一个很重要的需求:我们需要知道从某一个点开始,到其他所有点的最短路径。

        这其中,Dijkstra算法是典型的最短路径算法。它的关键思想是以起始点为中心,向外一层层扩散,直到扩展到终点为止。Dijkstra算法能够得出最短路径的最优解,不过它需要遍历计算的节点相当多,所以效率不高。

     

        首先,用最通俗的语言解释。假定有3个顶点,ABC,如图:

     

    要求A到其余各点的最短路径。很明显,ACAB更短。有疑惑的是从A->B的最短距离,要么是直接A->B的边,要么是A经过CB的边更短。我们首先找到最短的边(A->C),然后在此基础上扩展,于其余边去对比找到最小值。顶点再进一步扩充增加,按照这个思想,我们总可以找到A到所有点的最短路径。

     

     

    算法具体步骤

     

     1.初始时,S中只有源点,即S = {v}v的距离为0(到自己的距离为0)。U包含除v外地所有其他顶点,U中顶点u距离为边上的权(若vu存在边)或 ∞ (vu不存在边,即u不是v的出边邻接点)

     2.U中选取一个距离v最小的顶点k加入到S中(选定的距离就是vk的最短路径)

     3.k为新考虑的中间点,修改U中各顶点的距离。若从源点v经过顶点k到顶点u的距离比原来距离(不经过顶点k)短,则修改顶点u的距离,修改后的距离值为顶点k的距离加上边k->u的权

     4.重复步骤23直到所有的顶点都加入到S


     再看一个例子:

     


    步骤

    S集合中      

    U集合中

    1   

    选入A,此时S ={A}

    此时最短路径A->A = 0

    A为中间点,从A开始找

    U = {B, C, D, E, F}

    A->B = 6

    A->C = 3

    A->U中其他顶点 = 

    其中A->C = 3 权值为最小,路径最短

    2

    选入上一轮中找到的最短路径的顶点C,此时S = {A, C}

    此时最短路径A->A = 0A->C = 3

    C为中间点,从A->C=3这条最短路径开始新一轮查找

    U = {B, D, E, F}

    A->C->B = 5(比上面的A->B = 6要小)

    替换B的权值为更小的A->C->B = 5

    A->C->D = 6

    A->C->E = 7

    A->C->U中其他顶点 = 

    其中A->C->B = 5 最短

    3

    选入B,此时S = {A, C, B}

    此时最短路径 A->A = 0A->C = 3

    A->C->B = 5

    B为中间点,从A->C->B = 5这条最短路径开始新一轮查找

    U = {D, E, F}

    A->C->B->D = 10(比上面的A->C->D = 6大,不替换,保持D的权值为A->C->D=6)

    A->C->B->U中其他顶点 = 

    其中 A->C->D = 6 最短

    4

    选入D,此时 S = {A, C, B, D}

    此时最短路径 A->A = 0A->C = 3A->C->B = 5A->C->D = 6

    D为中间点,从A->C->D = 6这条最短路径开始新一轮查找

    U = {E, F}

    A->C->D->E = 8(比上面步骤2中的A->C->E = 7要长,保持E的权值为A->C->E =7)

    A->C->D->F = 9

    其中A->C->E = 7最短

    5

    选入E,此时 S = {A, C, B, D ,E}

    此时最短路径 A->A = 0A->C = 3A->C->B = 5A->C->D = 6A->C->E =7,

    E为中间点,从A->C->E = 7这条最短路径开始新一轮查找

    U = {F}

    A->C->E->F = 12(比第4步中的A->C->D->F = 9要长,保持F的权值为A->C->D->F = 9)

    其中A->C->D->F =9最短

    6

    选入F,此时 S = {A, C, B, D ,E, F}

    此时最短路径 A->A = 0A->C = 3A->C->B = 5A->C->D = 6A->C->E =7,A->C->D->F = 9

    U集合已空,查找完毕

      



    

    展开全文
  • 迪杰斯特拉关键理念:找出图中开销最低的节点,并保证没有到该节点开销更低的路径 以下面的图为例: 要解决这个问题,需要三个散列表:  graph 起点 A 6 B 2 A final 1 B A 3 ...
  • 关键:将弧按权值递增排序,按到起点路径长度的从小到大加入U。 这样做,下一条构成的路径(设终点为x),必然是v0到vx的最短路径,且必定是b2或者是B1+b2。即,v0到vx的最短路径不会是通过A1 + a2 + A3这种方法产生...
  • 核心是动态更新三个数组...假如G为起点,先到可以直接到达的顶点,再找路径最短的那个顶点到其他没有到过的顶点。 package Dijkstra; import java.util.Arrays; /** * @author pdzz * @create 2019-12-02 17:1...
  • 实验七 图的深度优先遍历(选做,验证性实验,4学时) 实验目的 熟悉图的数组表示法和邻接表存储结构,掌握构造有向图、无向图的算法 ,在掌握以上知识的基础上,...(4)在邻接表上实现拓扑排序、关键路径的求...
  • 关键代码 vector<int> Dijkstra(vector<vector<int>> matrix,int s) { //matrix邻接矩阵,s源点 int n = matrix.size(); //节点总数 vector<int> dis(n,INF); //distance记录最短路径...
  • 迪杰斯特拉(dijkstra)算法详解

    千次阅读 2016-03-02 15:21:41
    它的关键思想是以起始点为中心,向外一层层扩散,直到扩展到终点为止。Dijkstra算法能够得出最短路径的最优解,不过它需要遍历计算的节点相当多,所以效率不高。    首先,用最通俗的语言解释。假定有3个...
  • dijkstra可以找出每个点的前一个点, 所以dfs搜索比较的时候怎么处理携带和带走的数量就是关键,考虑到这个携带和带走和路径顺序有关,所以可以用下面的写法,看代码就可以了。 最开始的时候是想用一个偏动态规划的...
  • 这里只说明关键部分。 有三个优先级,由高到低分别是: 距离、高兴值、平均高兴值。 距离即是最普通的Dijkstra所求的目标。 高兴值是点权变体之一。 平均高兴值可化为求最短路径中的最少结点路径,也属于点权...
  • 图:关键路径和最短路径

    千次阅读 2019-03-09 15:17:10
    文章目录关键路径最短路径 关键路径 顶点是事件i和事件j,边的权值是活动所需的时间 例子: ...第一步:确定哪些活动...将每一顶点当作源点,依次调用迪杰斯特拉算法,同样可以得到每一对顶点之间的最短路径,事...
  • 最短路径迪杰斯特拉算法原文分析思路(理解不了这里就pass掉):在有向网中,从某一源点到其余各点都有一条最短路径。首先在这些最短路径中,长度最短的必定只有一条弧,且它的权值是从源点出发的所有弧上权的最小值...
  • 参考书目:《王道论坛之数据结构联考复习指导》 在学习数据结构部分时对图的应用(最短路径和关键路径)...一、最短路径问题(Dijkstra迪杰斯特拉算法->求单源最短路径【步骤法和表格法】、Floyd弗洛伊德算法-&g...
  • 当时卡了好一会,后来改出来了,我是用迪杰斯特拉做的,这里迪杰斯特拉要改几条语句,否则路径不对,然后后面问了下大佬,说是关键路径也可以做 迪杰斯特拉改的关键 关键就是迪杰斯特拉更新节点 i 的时候要重置 i ...
  • 单源点最短路径——迪杰斯特拉(Dijkstra)算法 多源点最短路径——佛洛伊德(Floyd)算法 2.Dijkstra算法 ——从一个指定给源点到图上其余各点的最短路径 【思路】按路径长度递增的次序产生最短路径 引进一个...
  • 文章目录最短路径的6种算法广度优先/深度优先遍历Dijkstra迪杰斯特拉算法贝尔曼Dellman-ford算法弗洛伊德Floyd-Warshall算法利用拓扑排序(关键路径)建立算法SPFA快速算法 最短路径的6种算法 广度优先/深度优先遍历...
  • 本题采用迪杰斯特拉算法求最短路径。 由于迪杰斯特拉算法的特性,求所有终点的最短路径好求。 关键是不定起点的要求。 不过代码还是很好改。 算是模板题了 代码如下: #include #include #i
  • 图的遍历 深度优先遍历、广度优先遍历 最小生成树 普里姆算法 克鲁斯卡尔算法 最短路径 迪杰斯特拉算法 弗洛伊德算法 拓扑排序 AOV网,无权值 关键路径 AOE网,有权值 ...
  • 2019-08-30 13:45:09
    目录 图 定义 无向图 有向图 简单图 无向完全图 有向完全图 带权图 网 子图 图的存储结构 ...迪杰斯特拉(Dijkstra )算法 弗洛伊德(Floyd )算法 对比 拓扑排序 算法 关键路径 图...
  • 这是LeetCode上的一道题,给定一张图,寻找概率最大的路径。... // 迪杰斯特拉算法解决,用BFS+优先级队列实现 public double maxProbability(int n, int[][] edges, double[] succProb, int start, int end) { Li
  • 目录问题 A: DS图—图的最短路径(不含代码框架)问题 B: 图综合练习--拓扑排序问题 C: 追星问题 D: 关键路径-STL版 问题 A: DS图—图的最短路径(不含代码框架) 题目描述 给出一个图的邻接矩阵,输入顶点v,用...
  • 迪杰斯特拉二. 弗洛伊德算法拓扑排序一. 拓扑排序的概念二. 拓扑排序的算法关键路径一. 概念二. 关键路径算法 图的定义 图(Graph)是由顶点的有穷非空集合和顶点之间边的集合组成,通常表示:G(...
  • 关于图的一些算法

    2020-04-13 20:27:31
    Prim和克鲁斯卡尔:求最小生成树 迪杰斯特拉:求一个顶点到其他所有顶点的最短路径 弗洛伊德:求所有顶点之间的最短路径。 关键路径:求工程的最短时间 ...
  • 数据结构之 图

    2019-07-15 00:10:00
    图这一章是整本数据结构书中最复杂的一章,涉及多个算法,现在整理如下: 遍历算法:广度优先、深度优先 最小生成树:普里姆算法、...最短路径:迪杰斯特拉算法。佛洛伊得算法。 拓扑排序算法。 关键路径算法。 ...
  • 文章目录1.最小生成树1.1普里姆(Prim)算法(加点法)1.2克鲁斯卡尔(Kruskal)算法(加边法)1.3...关键路径4.1AOE网4.1.1AOE--网的定义4.2关键路径的求解过程4.2.1如何确定关键路径,需要定义4个描述量4.2.2如何找l(i)

空空如也

空空如也

1 2 3 4
收藏数 72
精华内容 28
关键字:

关键路径迪杰斯特拉