最短路径算法-Floyd zz

最新推荐文章于 2021-08-02 21:09:11 发布
最新推荐文章于 2021-08-02 21:09:11 发布
阅读量647 收藏
点赞数
分类专栏： 编程-算法 文章标签： 算法 path algorithm c struct input

 

  如果有一个矩阵D=[d(ij)]，其中d(ij)>0表示i城市到j城市的距离。若i与j之间无路可通，那么d(ij)就是无穷大。又有d(ii)=0。编写一个程序，通过这个距离矩阵D，把任意两个城市之间的最短与其行径的路径找出来。
     我们可以将问题分解，先找出最短的距离，然后在考虑如何找出对应的行进路线。如何找出最短路径呢，这里还是用到动态规划的知识，对于任何一个城市而言，i到j的最短距离不外乎存在经过i与j之间的k和不经过k两种可能，所以可以令k=1，2，3，…，n(n是城市的数目)，在检查d(ij)与d(ik)+d(kj)的值；在此d(ik)与d(kj)分别是目前为止所知道的i到k与k到j的最短距离，因此d(ik)+d(kj)就是i到j经过k的最短距离。所以，若有d(ij)>d(ik)+d(kj)，就表示从i出发经过k再到j的距离要比原来的i到j距离短，自然把i到j的d(ij)重写为d(ik)+d(kj)，每当一个k查完了，d(ij)就是目前的i到j的最短距离。重复这一过程，最后当查完所有的k时，d(ij)里面存放的就是i到j之间的最短距离了。所以我们就可以用三个for循环把问题搞定了，但是有一个问题需要注意，那就是for循环的嵌套的顺序：我们可能随手就会写出这样的程序，但是仔细考虑的话，会发现是有问题的。

                     for(int i=0; i<n; i++)
                           for(int j=0; j<n; j++)
                                for(int k=0; k<n; k++)  
    

     问题出在我们太早的把i-k-j的距离确定下来了，假设一旦找到了i-p-j最短的距离后，i到j就相当处理完了，以后不会在改变了，一旦以后有使i到j的更短的距离时也不能再去更新了，所以结果一定是不对的。所以应当象下面一样来写程序：

                    for(int k=0; k<n; k++)
                         for(int i=0; i<n; i++)
                              for(int j=0; j<n; j++)

    这样作的意义在于固定了k，把所有i到j而经过k的距离找出来，然后象开头所提到的那样进行比较和重写，因为k是在最外层的，所以会把所有的i到j都处理完后，才会移动到下一个k，这样就不会有问题了，看来多层循环的时候，我们一定要当心，否则很容易就弄错了。
     接下来就要看一看如何找出最短路径所行经的城市了，这里要用到另一个矩阵P，它的定义是这样的：p(ij)的值如果为p，就表示i到j的最短行经为i->…->p->j，也就是说p是i到j的最短行径中的j之前的最后一个城市。P矩阵的初值为p(ij)=i。有了这个矩阵之后，要找最短路径就轻而易举了。对于i到j而言找出p(ij)，令为p，就知道了路径i->…->p->j；再去找p(ip)，如果值为q，i到p的最短路径为i->…->q->p；再去找p(iq)，如果值为r，i到q的最短路径为i->…->r->q；所以一再反复，到了某个p(it)的值为i时，就表示i到t的最短路径为i->t，就会的到答案了，i到j的最短行径为i->t->…->q->p->j。因为上述的算法是从终点到起点的顺序找出来的，所以输出的时候要把它倒过来。
     但是，如何动态的回填P矩阵的值呢？回想一下，当d(ij)>d(ik)+d(kj)时，就要让i到j的最短路径改为走i->…->k->…->j这一条路，但是d(kj)的值是已知的，换句话说，就是k->…->j这条路是已知的，所以k->…->j这条路上j的上一个城市(即p(kj))也是已知的，当然，因为要改走i->…->k->…->j这一条路，j的上一个城市正好是p(kj)。所以一旦发现d(ij)>d(ik)+d(kj)，就把p(kj)存入p(ij)。
   下面是具体的C代码：
   #include            
   #include            
   #include            
   #define   MAXSIZE   20        

   void  floyd(int [][MAXSIZE], int [][MAXSIZE], int);
   void  display_path(int [][MAXSIZE], int [][MAXSIZE], int);
   void  reverse(int [], int);
   void  readin(int [][MAXSIZE], int *);

   #define   MAXSUM(a, b)   (((a) != INT_MAX && (b) != INT_MAX) ? /
                          ((a) + (b)) : INT_MAX)

   void floyd(int dist[][MAXSIZE], int path[][MAXSIZE], int n)
   {
       int  i, j, k;
       for (i = 0; i < n; i++)  
           for (j = 0; j < n; j++)
               path[i][j] = i;
       for (k = 0; k < n; k++)  
           for (i = 0; i < n; i++)
               for (j = 0; j < n; j++)  
                    if (dist[i][j] > MAXSUM(dist[i][k], dist[k][j]))
                    {
                         path[i][j] = path[k][j];
                         dist[i][j] = MAXSUM(dist[i][k], dist[k][j]);
                    }
   }

   void display_path(int dist[][MAXSIZE], int path[][MAXSIZE], int n)
   {
       int  *chain;
       int  count;
       int  i, j, k;
       printf(“/n/nOrigin->Dest   Dist   Path”);
       printf(  ”/n—————————–”);
       chain = (int *) malloc(sizeof(int)*n);
       for (i = 0; i < n; i++)
           for (j = 0; j < n; j++)
           {
               if (i != j)
               {  
                    printf(“/n%6d->%d    ”, i+1, j+1);
                    if (dist[i][j] == INT_MAX)
                         printf(“  NA    ”);
                    else
                    {
                         printf(“%4d    ”, dist[i][j]);
                         count = 0;  
                         k = j;
                         do
                         {
                             k = chain[count++] = path[i][k];
                         } while (i != k);
                         reverse(chain, count);
                         printf(“%d”, chain[0]+1);
                         for (k = 1; k < count; k++)
                              printf(“->%d”, chain[k]+1);
                         printf(“->%d”, j+1);
                    }
               }
           }
       free(chain);            
   }

   #define SWAP(a, b)  { temp = a; a = b; b = temp; }

   void reverse(int x[], int n)
   {
       int  i, j, temp;
       for (i = 0, j = n-1; i < j; i++, j–)
            SWAP(x[i], x[j]);
   }

   void readin(int dist[][MAXSIZE], int *number)
   {
       int  origin, dest, length, n;
       int  i, j;
       char line[100];
       gets(line);              
       sscanf(line, “%d”, &n);
       *number = n;
       for (i = 0; i < n; i++)
       {
           for (j = 0; j < n; j++)
                dist[i][j] = INT_MAX;
           dist[i][i] = 0;    
       }
       gets(line);              
       sscanf(line, “%d%d%d”, &origin, &dest, &length);
       while (origin != 0 && dest != 0 && length != 0)
       {
          dist[origin-1][dest-1] = length;
          gets(line);        
          sscanf(line, “%d%d%d”, &origin, &dest, &length);
       }
   }
     测试程序如下所示：
   int main(void)
   {
       int dist[MAXSIZE][MAXSIZE];
       int path[MAXSIZE][MAXSIZE];
       int n;
       printf(“/nInput the path information:”);
       printf(“/n—————————-/n”);
       readin(dist, &n);
       floyd(dist, path, n);
       display_path(dist, path, n);
       getchar();
   }
     其中readin函数规定了输入的格式，第一列是指出有多少个城市；第二列以后每行三个数；第一个和第二个是一条路径的起点和终点，第三个数是路径的长度，最后以三个0作为输入结束条件。下面是一个输入的例子：
              Input the path information:
            ————————————–
              4
              1          2          5
              2          1          50
              2          3          15
              2          4          5
              3          1          30
              3          4          15
              4          1          15
              4          3          5
              0          0          0
   对应的输出结果为：
     Origin->Dest      Dist          Path
  ———————————————-
        1->2             5           1->2
        1->3            15          1->2->4->3
        1->4            10          1->2->4
        2->1            20          2->4->1
        2->3            10          2->4->3
        2->4             5           2->4
        3->1            30          3->1
        3->2            35          3->1->2
        3->4            15          3->4
        4->1            15          4->1
        4->2            20          4->1->2
        4->3             5           4->3

 

 

floyd算法用以解决所有点对最短路径。

floyd算法基本思想是递推，动态规划。我们记 dp[i][j][k] 表示图中顶点 i 到 j 的最短路径，且该最短路径中，所经过的中间顶点(不包括 i, j) 的范围为 [1,k]，由此我们可以得到以下递推式：

dp[i][j][k]= w[i][j]   如果 k== 0

dp[i][j][k]= min{ dp[i][k][k-1]+ dp[k][j][k-1] }  如果 k>= 1。

实际中，空间上我们可以减少一维。

 

floyd算法同样可以来解决一些其它问题

1) 有向图的最小(或最大)环

这个问题答案其实就是自身到自身的最短路径，运行完 floyd 后，对每个顶点取自身到自身距离的最小者。

 

2) 无向图的最小环

根据以上的递推式，dp[i][j][k] 表示 i 到 j 的最短路径，且该最短路径中，所经过的中间顶点(不包括 i, j) 的范围为 [1,k]。

此时我们可以枚举出顶点序列最大为 k+ 1 的所有最小环，如何枚举：设与顶点序列最大的顶点 k+ 1 相连的两个顶点为 x, y，x,y 须满足 x, y<= k。这样最小环构成为 边<x,k+1>  边<k+ 1, y> 及 x 到 y 的最短路径。

Poj 1734 Sightseeing trip

#include <stdio.h>
#include <stdlib.h>

int const N= 110, inf= 5000000;
int mat[N][N], dist[N][N], pre[N][N], path[N], n, m, top= 0, p;

#define min(a,b) ((a)<(b)?(a):(b))

int main(){
    scanf("%d%d",&n,&m );
    for( int i= 0; i<= n; ++i )
    for( int j= 0; j<= n; ++j ){
        mat[i][j]= inf; dist[i][j]= inf; pre[i][j]= j; }
    while( m-- ){
        int u, v, d;
        scanf("%d%d%d",&u,&v,&d);
        mat[u][v]= min( mat[u][v], d );
        mat[v][u]= mat[u][v];
        dist[u][v]= mat[u][v]; dist[v][u]= mat[v][u];
    }
    int ans= inf;
    for( int k= 1; k<= n; ++k ){
        for( int x= 1; x< k; ++x )
        for( int y= 1; y< x; ++y ){
            if( mat[x][k]+ mat[k][y]+ dist[x][y]< ans ){
                ans= mat[x][k]+ mat[k][y]+ dist[x][y];
                top= 0; path[top++]= k; p= x;
                while( y ){
                    path[top++]= p; p= pre[p][y];
                }
                path[top++]= y;
            }
        }
        for( int i= 1; i<= n; ++i )
        for( int j= 1; j<= n; ++j )
        if( dist[i][k]+ dist[k][j]< dist[i][j] ){
            dist[i][j]= dist[i][k]+ dist[k][j];
            pre[i][j]= pre[i][k]; }
    }
    if( top> 0 ){
        printf("%d", path[0] );
        for( int i= 1; i< top; ++i ) printf(" %d", path[i] );
        puts("");
    }else puts("No solution.");
    
    return 0;
}

 

3) 带限制的多点对最短路径

TOJ 3214 Find the Path
题意为给一个城市图，每个城市 i 有 ci 个警察，现有两个城市 u 和 v，找一条最短路径使得最短路径上任意一个城市的警察数量不大于 k。解法依然用到了 floyd 算法的思想，回到 dp[i][j][k] 表示图中顶点 i 到 j 的最短路径，且该最短路径中，所经过的中间顶点(不包括 i, j) 的范围为 [1,k] 这个定义，在这个问题中，我们加入中间顶点时按照警察数量从小到大的顺序加入。所以 dp[i][j][k] 所得到的最短路径中，每一个中间顶点的警察数量不会超过顶点 k 的警察数量。
代码

#include <iostream>
#include <algorithm>
#include <cstdio>

using namespace std;
int const N= 205, inf= 2000000;
struct Node{
    int cops, id;
}c[N];
int mat[N][N][N], n, m;

bool operator<(Node a, Node b ){
    return a.cops< b.cops; }
    
int main(){
    int test;
    scanf("%d", &test );
    while( test-- ){
        scanf("%d%d",&n,&m );
        for( int i= 1; i<= n; ++i ){
            scanf("%d", &c[i].cops);
            c[i].id= i; }
        
        sort( c+ 1, c+ 1+ n );
        
        for( int i= 0; i<= n; ++i )
        for( int j= 0; j<= n; ++j )
        mat[i][j][0]= inf;
        
        while( m-- ){
            int u, v, d;
            scanf("%d%d%d",&u,&v,&d );
            u++,v++;
            mat[u][v][0]= d; mat[v][u][0]= d;
        }
        
        for( int k= 1; k<= n; ++k ){
            for( int i= 1; i<= n; ++i )
            for( int j= 1; j<= n; ++j )
            mat[i][j][k]= mat[i][j][k-1];
            
            for( int i= 1; i<= n; ++i )
            for( int j= 1; j<= n; ++j ){
                int p= c[k].id;
                if( mat[i][p][k-1]+ mat[p][j][k-1]< mat[i][j][k] )
                mat[i][j][k]= mat[i][p][k-1]+ mat[p][j][k-1];
            }
        }
        int q;
        scanf("%d",&q );
        while( q-- ){
            int u, v, k;
            scanf("%d%d%d",&u,&v,&k );
            u++, v++;
            
            int i= 1;
            while( i<= n && c[i].cops<= k ) i++; i--;
            
            if( mat[u][v][i]!= inf ) printf("%d/n", mat[u][v][i] );
            else puts("-1");
        }
        puts("");
    }
    return 0;
}

 

4) floyd 与有向图的连通性

有向图的传递闭包可以用 floyd 算法求出。
ZOJ 3232  It's not Floyd Algorithm
题意为给出一个已经做过传递闭包的矩阵，求出原图最少由多少边组成。
先考虑原图与做过传递闭包后的新图的关系：对于原图中的强连通分量，做过传递闭包后，强连通分量就变成了团，任意两点都有边，所以新图中求得强连通分量一定是一个团，对于团，一定可以找到一个环把所有顶点连起来。可以证明，对于新图中的有 n(n>1) 个顶点的强连通分量，原图中至少需要 n 条边才能构成，只要取一个环就行了。把所有强连通分量处理后，这时的新图就了一个有向无环，这时我们可以做反闭包，求出剩余图所需的边数。
代码：

#include <stdio.h>
#include <stdlib.h>

int const N= 210;
int n, mat[N][N], map[N][N];
int dep[N], low[N], mark[N], stack[N], cnt, top, c, num[N];

void dfs( int u ){
    dep[u]= ++cnt; low[u]= dep[u]; stack[++top]= u;
    for( int v= 1; v<= n; ++v )
    if( mat[u][v] ){
        if( dep[v]== 0 ) {
            dfs( v );
            if( low[v]< low[u] ) low[u]= low[v];
        }
        else if( low[v]!= n && dep[v]< low[u] ) low[u]= dep[v];
    }
    if( dep[u]== low[u] ){
        c++;
        do{
            int v= stack[top];
            mark[v]= c; low[v]= n;
        }while( stack[top--]!= u );
    }
}

int main(){
    while( scanf("%d",&n)!= EOF ){
        for( int i= 0; i<= n; ++i )
        for( int j= 0; j<= n; ++j ) {
            mat[i][j]= 0; map[i][j]= 0; }
        
        for( int i= 1; i<= n; ++i )
        for( int j= 1; j<= n; ++j )
        scanf("%d", &mat[i][j] );

lyso1
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Floyed算法
weixin_46503238的博客
04-08 3133
Floyed-Warshall算法定义 floyed主要解决多源最短路径问题,可以求出任意两点间的最短路径,以简单便捷著称! 实现过程 floyed的实质是动态规划思想(将小规模问题的解存储在内存中,等到大问题的解直接拿来有效利用,这就是动态规划的基本思路),floyed通过3层for循环,先确定k值,然后每一个起始结点u,通过k到达v(d[u][k]+d[k][v]),与原来的d[u][v]进行比较选出较小的值。 主要代码 for(int k=1;k<=n;k++) for(int i=1
图论最短路径算法（一）Floyed算法（弗洛伊德算法）
程序员世杰
04-08 1992
文章目录Floyed-Warshall算法 O(N^3^)算法描述：算法分析&思想讲解：Floyed算法变形：应用场景【例1】最短路径问题 Floyed-Warshall算法 O(N3) 简称Floyed(弗洛伊德)算法，是最简单的最短路径算法，可以计算图中任意两点间的最短路径。Floyed的时间复杂度是O (N3)，适用于出现负边权的情况。 以下没有特别说明的话，dis[u][v]表...
弗洛伊德算法和迪杰斯特拉算法相比有什么优势?_常用十大算法之 其十·弗洛伊德算法【日后详细补充】...
weixin_31951365的博客
01-27 3287
介绍和Dijkstra算法一样，弗洛伊德(Floyd)算法也是一种用于寻找给定的加权图中顶点间最短路径的算法。该算法名称以创始人之一、1978年图灵奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德命名弗洛伊德算法(Floyd)计算图中各个顶点之间的最短路径迪杰斯特拉算法用于计算图中某一个顶点到其他顶点的最短路径。弗洛伊德算法 VS 迪杰斯特拉算法：迪杰斯特拉算法通过选定的被访问顶点，求出从出发...
Floyed那些事~~~~~
weixin_34041003的博客
03-16 193
显然Floyed算法是一个简短而好理解的算法，这里指的好理解是 因为Floyed的代码长度不大，实在没理解都可以背下来，所以说是好理解，实际上是真的好理解吗？我们来看看 最基础的Floyed Floyed是什么？自然是用来求多源最短路的啦，时间效率是O(n^3)，有人会问那我不对每个点做一遍SPFA或dijkstra堆优化，时间效率是O(n^2logn)那不是快很多？实...
迪杰斯特拉和弗洛伊德算法
qq_51340322的博客
08-02 5510
迪杰斯特拉和弗洛伊德算法 文章目录迪杰斯特拉和弗洛伊德算法一、迪杰斯特拉算法：1. dijkstra算法概述2. dijkstra算法原理3. 关于路径输出4. 完整代码展示5. 测试图例及结果二、弗洛伊德算法：1. floyed算法概述2. floyed算法原理3. 关于路径输出问题4. 完整代码展示5. 测试图例与结果 一、迪杰斯特拉算法： 1. dijkstra算法概述 迪杰斯特拉算法(Dijkstra)是由荷兰计算机科学家狄克斯特拉于1959年提出的，因此又叫狄克斯特拉算法。是从一个顶点到其余各顶点
最短路径-Floyd算法
J_2333的博客
03-08 277
1. 问题 给定带权有向图G＝(V, E)，对任意顶点vi,vj∈V（i≠j），求顶点vi到顶点vj的最短路径。 2. 解析 ①首先，先将图中的数据放入矩阵中存储。比如1→2的距离是2，则设e[1][2]的值为2，2→4无法完成，则设e[2][4]的值为∞，另约定点到自己的距离为0，即e[1][1]的值为0，以此类推。具体如下： ②假设只允许经过1号点，只需要判断e[i][1]+e[i][j]...
最短路径Floyd算法
AC_Gibson的专栏
12-08 667
前面我们介绍了单源最短路径问题的Dijkstra算法，Dijkstra算法虽然有比较好看的复杂度，但其对于有负权值的图来将，就显得力不从心了，下面我们来介绍另一种更为广泛的最短路径问题的解法：Floyd算法 Floyd算法（弗洛伊德）算法的原理基于动态规划，比如要找出1到k这些点中从a到b的最短路径（dist（a，b）），我们把从a到b所经过的路径分为两部分，经过某一点x，和必经过x点；对于经过
6.4.4 最短路径问题 - Floyd算法1
08-03
本节内容王道考研/CSKAOYAN.COM最短路径Floyd算法王道考研/CSKAOYAN.COM罗伯特·弗洛伊德1978年图灵奖得主• Floyd算法（Flo
算法-最短路径-Floyd算法
05-21
Floyd-Warshall算法，通常简称为Floyd算法，是一种用于解决所有对之间最短路径问题的有效算法。由Robert W. Floyd在1962年提出，该算法的核心思想是基于动态规划，通过逐步考虑所有可能的中间节点来寻找两点间的最短...
floyd最短路径算法MATLAB代码
08-29
求最短路径的Floyd算法实现，无向图和有向图均适用。1先区别有向图和无向图，2输入顶点数和边数并检查合法性，3输入每边的起点、终点、权重并检查合法性，并初始化邻接矩阵和路径矩阵，4调用自定义函数Floyd
floyed算法
06-01
floyed算法，计算最短路径的算法，输入矩阵，即可输出最短路径矩阵
Floyd算法，求有向图中各顶点之间的最短路径及其长度
09-30
用Floyd算法实现求有向图中各顶点之间的最短路径及其长度
动态规划--Floyd算法
11-11
动态规划--Floyd算法，基础算法，希望对大家有帮助。
基于matlab算最短路径--Floyd算法.rar_matlab_
08-10
Floyd算法，也称为Floyd-Warshall算法，是由Robert Floyd在1962年提出的。该算法主要用于寻找图中所有顶点之间的最短路径。其基本思想是通过逐步增加中间节点，更新每对顶点之间的最短路径。在MATLAB中实现这个算法...
Floyd最短路径算法_Floyd算法_write8lf_matlab_弗洛伊德算法_最短路径_源码
10-02
**Floyd最短路径算法**，也称为Floyd-Warshall算法，是计算机科学中用于求解图论问题的一种经典算法。它能有效地找到图中所有顶点对之间的最短路径，尤其适用于处理大型网络中的路径查找问题。Floyd算法的核心思想是...
Floyd - Warshall（弗洛伊德算法）
yuewenyao的博客
07-12 6万+
简介：Floyd算法又称为插点法，是一种利用动态规划的思想寻找给定的加权图中多源点之间最短路径的算法，与Dijkstra算法类似。该算法名称以创始人之一、1978年图灵奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德命名。 eg：暑假，小哼准备去一些城市旅游。有些城市之间有公路，有些城市之间则没有，如下图。为了节省经费及方便计划旅程，小哼希望在出发前知道任意两个城市之...
分布式系统因果一致性与COPS算法
luyaran的博客
07-03 1135
COPS是保序系统的集群(Clusters of Order Preserving System)的简称。在了解COPS之前，最好首先了解一下分布式系统CAC算法，从CAP-->CAC-->COPS是分布式系统的确保高性能低延迟高可扩展性的前提下追求高一致性直至事务机制的发展路径。 　　COPS系统能够提供因果+一致性causal+ consistency，设计为支持复杂的在线应用，这些应用
Floyd（弗洛伊德算法） 求最短路径 有向图
yjyxw的博客
04-24 3410
暑假，小哼准备去一些城市旅游。有些城市之间有公路，有些城市之间则没有，如下图。为了节省经费以及方便计划旅程，小哼希望在出发之前知道任意两个城市之前的最短路程。 上图中有4个城市8条公路，公路上的数字表示这条公路的长短...
最短路径问题---Floyd算法详解
热门推荐
William
03-11 29万+
前言 Genius only means hard-working all one’s life. Name:Willam Time:2017/3/81、最短路径问题介绍问题解释： 从图中的某个顶点出发到达另外一个顶点的所经过的边的权重和最小的一条路径，称为最短路径解决问题的算法： 迪杰斯特拉算法（Dijkstra算法） 弗洛伊德算法（Floyd算法） SPFA算法 之前已经对Di
最短路径算法(floyd--)
最新发布
06-20
最短路径算法是一种在图论中寻找从起始节点到目标节点最短路径的算法。Floyd-Warshall算法是一种常用的动态规划方法，也称为Floyd算法或Floyd-Farshal算法。以下是Floyd-Warshall算法的主要特点： 1. **适用性**：该算法适用于所有类型的图（包括有向图和无向图），并且可以处理负权边，但不能处理具有负环的图。 2. **基本思想**：算法通过迭代计算所有节点对之间的最短路径，每次迭代都根据已知的最短路径更新可能更短的路径。 3. **步骤**： - 初始化一个矩阵D，其中D[i][j]表示从节点i到节点j的最短路径，初始时D[i][i]为0，其他值为无穷大。 - 对于每个中间节点k，检查是否存在一条通过节点k的更短路径，如果存在，则更新D[i][j]的值。 - 这个过程会重复进行V-1次，其中V是节点的数量，因为每一轮都可以发现新的最短路径。 4. **结束条件**：当所有V-1轮迭代完成后，矩阵D中的值就是最终的最短路径长度，而路径可以通过回溯找到。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值