最短路

对四种最短路算法的总结

博客来源：
转自 https://blog.csdn.net/JKdd123456/article/details/80615322
大佬博客 迪杰斯特拉算法
最短路的四种算法总结
师哥博客（代码来源）

最短路径问题介绍

问题解释：
从图中的某个顶点出发到达另外一个顶点的所经过的边的权重和最小的一条路径，称为最短路径

解决问题的算法：

1、迪杰斯特拉算法（Dijkstra算法）—–经典

2、弗洛伊德算法（Floyd算法）—–用三层循环

3、SPFA算法 —–最好用

4、Bellman-Ford(贝尔曼-福特) ——可以判断负环

1、Floyd 算法介绍

•  
• 1、算法的特点：

不能解决负权环的问题

弗洛伊德算法是解决任意两点间的最短路径的一种算法，可以正确处理有向图或有向图或负权的最短路径问题，同时也被用于计算有向图的传递闭包。

用三层 for 循环
通过Floyd计算图G=(V,E)中各个顶点的最短路径时，需要引入矩阵，
矩阵S中的元素 map[i][j] 表示顶点i(第i个顶点)到顶点j(第j个顶点)的距离。
假设图G中顶点个数为N，则需要对矩阵D和矩阵P进行N次更新。
初始时，矩阵D中顶点 map[i][j] 的距离为顶点i到顶点j的权值；
如果i和j不相邻，则 map[i][j]=∞。 接下来开始，对矩阵D进行N次更新。
第1次更新时，如果”a[i][j]的距离” > “a[i][k]+a[k][j]”
a[i][0]+a[0][j]表示”i与j之间经过第1个顶点的距离”，则更新a[i][j]为”a[i][0]+a[0][j]”。 同理，第k次更新时，如果”a[i][j]的距离” > “a[i][k-1]+a[k-1][j]”，则更新a[i][j]为”a[i][k-1]+a[k-1][j]”。更新N次之后，操作完成！
具体代码如下：

/*  不能判断负权环 */
   #include <stdio.h>
 2 int main()
 3 {
 4     int e[10][10],k,i,j,n,m,t1,t2,t3;
 5     int inf=99999999; 
         //用inf(infinity的缩写)存储一个我们认为的正无穷值
        //读入n和m，n表示顶点个数，m表示边的条数
 7     scanf("%d %d",&n,&m);
 8                               
 9     //初始化
10     for(i=1;i<=n;i++)
11         for(j=1;j<=n;j++)
12             if(i==j) e[i][j]=0;
13               else e[i][j]=inf;
14     //读入边
15     for(i=1;i<=m;i++)
16     {
17         scanf("%d %d %d",&t1,&t2,&t3);
18         e[t1][t2]=t3;
19     }
20      // floyd 核心算法                        
21      for(k=1;k<=n;k++)
23         for(i=1;i<=n;i++)
24             for(j=1;j<=n;j++)
25                 if(e[i][j]>e[i][k]+e[k][j] )
26                     e[i][j]=e[i][k]+e[k][j];
27                               
28     //输出最终的结果
29     for(i=1;i<=n;i++)
30     {
31      for(j=1;j<=n;j++)
32         {
33             printf("%10d",e[i][j]);
34         }
35         printf("
");
36     }
37                               
38     return 0;
39 }
/*
 有一点需要注意的是：如何表示正无穷。
 我们通常将正无穷定义为 0x3f3f3f3f，因为这样即使两个正无穷相加，
在实际应用中最好估计一下最短路径的上限，只需要设置比它大一点既可以。
如果你认为正无穷和其它值相加得到一个大于正无穷的数是不被允许的话，
我们只需在比较的时候加两个判断条件就可以了，
 */
 for(k=1;k<=n;k++)
3   for(i=1;i<=n;i++)
4       for(j=1;j<=n;j++)
5         if(e[i][k]<inf && e[k][j]<inf && e[i][j]>e[i][k]+e[k][j])
6             e[i][j]=e[i][k]+e[k][j];

2、Dijkstra算法介绍

• （1）、算法特点：

/*
迪杰斯特卡算法
按路径长度递增次序产生算法：
把顶点集合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算法采用的是一种贪心的策略，声明一个数组dis来保存源点到各个顶点的最短距离和一个保存已经找到了最短路径的顶点的集合：T，初始时，原点 s 的路径权重被赋为 0 （dis[s] = 0）。若对于顶点 s 存在能直接到达的边（s,m），则把dis[m]设为w（s, m）,同时把所有其他（s不能直接到达的）顶点的路径长度设为无穷大。初始时，集合T只有顶点s。
  然后，从dis数组选择最小值，则该值就是源点s到该值对应的顶点的最短路径，并且把该点加入到T中，OK，此时完成一个顶点，
  然后，我们需要看看新加入的顶点是否可以到达其他顶点并且看看通过该顶点到达其他点的路径长度是否比源点直接到达短，如果是，那么就替换这些顶点在dis中的值。
  然后，又从dis中找出最小值，重复上述动作，直到T中包含了图的所有顶点。

• l>

  （2）、Dijkstra算法示例演示

  下面看图，从顶点v1到其他各个顶点的最短路径

  

  首先第一步，我们先声明一个dis数组，该数组初始化的值为：
  

  我们的顶点集T的初始化为：T={v1}

  既然是求 v1顶点到其余各个顶点的最短路程，那就先找一个离 1 号顶点最近的顶点。通过数组 dis 可知当前离v1顶点最近是 v3顶点。当选择了 2 号顶点后，dis[2]（下标从0开始）的值就已经从“估计值”变为了“确定值”，即 v1顶点到 v3顶点的最短路程就是当前 dis[2]值。将V3加入到T中。
  为什么呢？因为目前离 v1顶点最近的是 v3顶点，并且这个图所有的边都是正数，那么肯定不可能通过第三个顶点中转，使得 v1顶点到 v3顶点的路程进一步缩短了。因为 v1顶点到其它顶点的路程肯定没有 v1到 v3顶点短.

  OK，既然确定了一个顶点的最短路径，下面我们就要根据这个新入的顶点V3会有出度，发现以v3 为弧尾的有： < v3,v4 >,那么我们看看路径：v1–v3–v4的长度是否比v1–v4短，其实这个已经是很明显的了，因为dis[3]代表的就是v1–v4的长度为无穷大，而v1–v3–v4的长度为：10+50=60，所以更新dis[3]的值,得到如下结果：
  

  因此 dis[3]要更新为 60。这个过程有个专业术语叫做“松弛”。即 v1顶点到 v4顶点的路程即 dis[3]，通过 < v3,v4> 这条边松弛成功。这便是 Dijkstra 算法的主要思想：通过“边”来松弛v1顶点到其余各个顶点的路程。

  然后，我们又从除dis[2]和dis[0]外的其他值中寻找最小值，发现dis[4]的值最小，通过之前是解释的原理，可以知道v1到v5的最短距离就是dis[4]的值，然后，我们把v5加入到集合T中，然后，考虑v5的出度是否会影响我们的数组dis的值，v5有两条出度：< v5,v4>和 < v5,v6>,然后我们发现：v1–v5–v4的长度为：50，而dis[3]的值为60，所以我们要更新dis[3]的值.另外，v1-v5-v6的长度为：90，而dis[5]为100，所以我们需要更新dis[5]的值。更新后的dis数组如下图：
  

  然后，继续从dis中选择未确定的顶点的值中选择一个最小的值，发现dis[3]的值是最小的，所以把v4加入到集合T中，此时集合T={v1,v3,v5,v4},然后，考虑v4的出度是否会影响我们的数组dis的值，v4有一条出度：< v4,v6>,然后我们发现：v1–v5–v4–v6的长度为：60，而dis[5]的值为90，所以我们要更新dis[5]的值，更新后的dis数组如下图：
  

  然后，我们使用同样原理，分别确定了v6和v2的最短路径，最后dis的数组的值如下：
  

  因此，从图中，我们可以发现v1-v2的值为：∞，代表没有路径从v1到达v2。所以我们得到的最后的结果为：

  起点  终点    最短路径    长度
  v1    v2     无          ∞    
        v3     {v1,v3}    10
        v4     {v1,v5,v4}  50
        v5     {v1,v5}    30
        v6     {v1，v5,v4,v6} 60
  

  e>r：

  /*           一、邻接矩阵实现 Dijkstra 
  */
  #include<iostream>
  #include<cstdio>
  #include<cstring>
  using namespace std;
  const int MAX=0x3f3f3f3f;
  int map[110][110];
  int dis[110];
  int visit[110];
  /*
  关于三个数组：map数组存的为点边的信息，比如map[1][2]=3，表示1号点和2号点的距离为3
  dis数组存的为起始点与每个点的最短距离，比如dis[3]=5，表示起始点与3号点最短距离为5
  visit数组存的为0或者1，1表示已经走过这个点。
  */
  int n,m;
  int dijkstra()
  {
      int i,j,pos=1,min,sum=0;
      memset(visit,0,sizeof(visit));//初始化为0，表示开始都没走过
      for(i=1; i<=n; i++)
      {
          dis[i]=map[1][i];
      }
      visit[1]=1;
      dis[1]=0;
      int T=n-1;
      while(T--)
      {
          min=MAX;
          for(j=1; j<=n; j++)
          {
              if(visit[j]==0&&min>dis[j])
              {
                  min=dis[j];
                  pos=j;
              }
          }
          visit[pos]=1;//表示这个点已经走过
          for(j=1; j<=n; j++)
          {
              if(visit[j]==0&&dis[j]>min+map[pos][j])//更新dis的值
                  dis[j]=map[pos][j]+min;
          }
      }
      return dis[n];
  }
  int main()
  {
      int i,j;
      while(cin>>n>>m)//n表示n个点，m表示m条边
      {
          memset(map,MAX,sizeof(map));
          int a,b,c;
          for(i=1; i<=m; i++)
          {
              cin>>a>>b>>c;
              if(c<map[a][b])//防止有重边
                  map[a][b]=map[b][a]=c;
          }
          int sum=dijkstra();
          cout<<sum<<endl;
      }
      return 0;
  }

  /*              二、 vector邻接表实现
  */
  #include <stdio.h>
  #include <string.h>
  #include <string>
  #include <vector>
  #include <algorithm>
  #define INF 0x3f3f3f3f
  
  using namespace std;
  
  struct node
  {
      int end;//终点
      int power;//权值
  } t;
  
  int n;//n为边数
  vector<node>q[500001];//邻接表存储图的信息
  int dis[500001];//距离数组
  bool vis[500001];//标记数组
  
  void Dijkstra(int start, int end)
  {
      memset(vis, false, sizeof(vis));
      for(int i=0; i<=n; i++)
      {
          dis[i] = INF;
      }
      int len=q[start].size();
      for(int i=0; i<len; i++)  
      {  
          //q[start][i]  start 代表的是 起点; i 是 与起点相连的第几个点
          if(q[start][i].power < dis[q[start][i].end] )
              dis[q[start][i].end]=q[start][i].power; //从起点开始的dis数组更新
      }
        //q[start][i].power  代表的是 与起点第 i 个相连的点 的权值
        //q[start][i].end  代表的是与起点第 i个相连的点 的终点
      vis[start]=true;//起点标记为1
  
      for(int k=0; k<n-1; k++)
      {
          int pos, min=INF;
          for(int i=1; i<=n; i++)
          {
              if( !vis[i] && dis[i]<min )
              {
                  //当前节点未被访问过且权值较小
                  min=dis[i];
                  pos=i;
              }
          }
  
          vis[pos]=true;
  
          //再次更新dis数组
          len=q[pos].size();
          for(int j=0; j<len; j++)
          {
              if( !vis[q[pos][j].end] && dis[ q[pos][j].end ]>q[pos][j].power+dis[pos] )
                  dis[q[pos][j].end ] = q[pos][j].power + dis[pos];
          }
      }
      printf("%d
  ", dis[end] );
  }
  
  
  int main()
  {
      int m;
      while(scanf("%d %d", &n, &m)&&n&&m)//输入点和边
      {
          for(int i=0; i<=n; i++)
              q[i].clear();//将vector数组清空
          for(int i=0; i<m; i++)
          {
              int begin,end, power;
              scanf("%d %d %d", &begin, &end, &power);//输入
              /*t作为node型临时变量，为了方便压入,以下代码为无向图的输入边*/
              t.end=end;
              t.power=power;
              q[begin].push_back(t);
              t.end=begin;
              t.power=power;
              q[end].push_back(t);
          }
          //Dijkstra(1, n);
          int start, end;//自己确定起始点和终止点
          scanf("%d %d", &start, &end);//输入起始点和终止点
          Dijkstra(start, end);
      }
      return 0;
  }

  3、SPFA 算法介绍

  很多时候，给定的图存在负权边，这时类似Dijkstra等算法便没有了用武之地，而Bellman-Ford算法的复杂度又过高，SPFA算法便派上用场了。有人称spfa算法是最短路的万能算法。

  简洁起见，我们约定有向加权图G不存在负权回路，即最短路径一定存在。当然，我们可以在执行该算法前做一次拓扑排序，以判断是否存在负权回路。
  我们用数组dis记录每个结点的最短路径估计值，可以用邻接矩阵或邻接表来存储图G，推荐使用邻接表。

  spfa的算法思想（动态逼近法）：
  设立一个 先进先出的队列q 用来保存待优化的结点，优化时每次取出 队首结点u， 并且用 u点当前的 最短路径估计值 对 离开u点所指向的结点 v 进行松弛操作，如果v点的最短路径估计值有所调整， 且v点不在当前的队列中，就将v点放入队尾。 这样不断从队列中取出结点来进行松弛操作，直至队列空为止。
  松弛操作的原理是著名的定理：“三角形两边之和大于第三边”，在信息学中我们叫它三角不等式，如果不满足三角形不等式的话，则进行松弛操作 （两边之和要比第三边的值小） ，所谓对结点i,j进行松弛，就是判定 是否dis[j]>dis[i]+w[i,j]， 如果该式成立则将dis[j]减小到dis[i]+w[i,j]，否则不动。
  下面举一个实例来说明SFFA算法是怎样进行的：
  
  

  /*
  判断负环：
  当一个点入队次数大于 N （点数）的时候，代表存在负环
  */
  int spfa_bfs(int s)
  {
      queue <int> q;
      memset(d,0x3f,sizeof(d));
      d[s]=0;
      memset(c,0,sizeof(c));
      memset(vis,0,sizeof(vis));
  
      q.push(s);  vis[s]=1; c[s]=1;
      //顶点入队vis要做标记，另外要统计顶点的入队次数
      int OK=1;
      while(!q.empty())
      {
          int x;
          x=q.front(); q.pop();  vis[x]=0;
          //队头元素出队，并且消除标记
          for(int k=f[x]; k!=0; k=nnext[k]) //遍历顶点x的邻接表
          {
              int y=v[k];
              if( d[x]+w[k] < d[y])
              {
                  d[y]=d[x]+w[k];  //松弛
                  if(!vis[y])  //顶点y不在队内
                  {
                      vis[y]=1;    //标记
                      c[y]++;      //统计次数
                      q.push(y);   //入队
                      if(c[y]>NN)  //超过入队次数上限，说明有负环
                          return OK=0;
                  }
              }
          }
      }
  
      return OK;
  
  }
  
  复制代码

  4、Bellman-Ford(贝尔曼-福特)

  Dijkstra算法是处理单源最短路径的有效算法，但它局限于边的权值非负的情况，
  若图中出现权值为负的边，Dijkstra算法就会失效，求出的最短路径就可能是错的。
  这时候，就需要使用其他的算法来求解最短路径，
  Bellman-Ford算法就是其中最常一个
  适用条件&范围：

  单源最短路径(从源点s到其它所有顶点v);

  有向图&无向图(无向图可以看作(u,v),(v,u)同属于边集E的有向图);

  边权可正可负(如有负权回路输出错误提示);

  给定图G(V, E)（其中V、E分别为图G的顶点集与边集），源点s，

  1.数组Distant[i]记录从源点s到顶点i的路径长度，初始化数组Distant[n]为, Distant[s]为0；

  2.以下操作循环执行至多n-1次，n为顶点数：

  对于每一条边e(u, v)，如果Distant[u] + w(u, v) < Distant[v]，则另Distant[v] = Distant[u]+w(u, v)。w(u, v)为边e(u,v)的权值；

  若上述操作没有对Distant进行更新，说明最短路径已经查找完毕，或者部分点不可达，跳出循环。否则执行下次循环；

  3.为了检测图中是否存在负环路，即权值之和小于0的环路。对于每一条边e(u, v)，如果存在Distant[u] + w(u, v) < Distant[v]的边，则图中存在负环路，即是说改图无法求出单源最短路径。否则数组Distant[n]中记录的就是源点s到各顶点的最短路径长度。

  可知，Bellman-Ford算法寻找单源最短路径的时间复杂度为O(V*E).

  首先介绍一下松弛计算。如下图：

  

  松弛计算之前，点B的值是8，但是点A的值加上边上的权重2，得到5，比点B的值（8）小，所以，点B的值减小为5。这个过程的意义是，找到了一条通向B点更短的路线，且该路线是先经过点A，然后通过权重为2的边，到达点B。

  当然，如果出现一下情况：

  

  则不会修改点B的值，因为3＋4>6。

  Bellman－Ford算法可以大致分为三个部分

  第一，初始化所有点。每一个点保存一个值，表示从原点到达这个点的距离，将原点的值设为0，其它的点的值设为无穷大（表示不可达）。

  第二，进行循环，循环下标为从1到n－1（n等于图中点的个数）。在循环内部，遍历所有的边，进行松弛计算。

  第三，遍历途中所有的边（edge（u，v）），判断是否存在这样情况：d（v） > d (u) + w(u,v)，存在则返回false，表示途中存在从源点可达的权为负的回路。

  之所以需要第三部分，是因为，如果存在从源点可达的权为负的回路。则应为无法收敛而导致不能求出最短路径。

  考虑如下的图：

  

  经过第一次遍历后，点B的值变为5，点C的值变为8，这时，注意权重为－10的边，这条边的存在，导致点A的值变为－2。（8＋ －10＝－2）

  

  第二次遍历后，点B的值变为3，点C变为6，点A变为－4。正是因为有一条负边在回路中，导致每次遍历后，各个点的值不断变小。

  在回过来看一下bellman－fo，则肯定能够在第三部分中检查出来。比如

  

  此时，点A的值为－2，点B的值为5，边AB的权重 5，5 > -2 + 5. 检查出来这条边没有收敛。

  所以，Bellman－Ford算法可以解决图中有权为负数的边的单源最短路径问题。
  代码如下：

  /*
  补充:
  考虑：为什么要循环V-1次？
  答：因为最短路径肯定是个简单路径，不可能包含回路的，
  如果包含回路，且回路的权值和为正的，那么去掉这个回路，可以得到更短的路径
  如果回路的权值是负的，那么肯定没有解了
  图有n个点，又不能有回路
  所以最短路径最多n-1边
  又因为每次循环，至少松弛一边
  所以最多n-1次就行了
  区别负权和负环：
  负权：至少有一条边是负的
  负环：相加和是负的
  判断负环：
  松弛完之后判断是否又进行了松弛，如果有的话就代表有负环，则用 flag 标记有负环
  */
  #include <iostream>
  using namespace std;
  const int maxnum = 100;
  const int maxint = 99999;
  
  // 边，
  typedef struct Edge{
      int u, v;    // 起点，重点
      int weight;  // 边的权值
  }Edge;
  
  Edge edge[maxnum];     // 保存边的值
  int  dist[maxnum];     // 结点到源点最小距离
  
  int nodenum, edgenum, source;    // 结点数，边数，源点
  
  // 初始化图
  void init()
  {
      // 输入结点数，边数，源点
      cin >> nodenum >> edgenum >> source;
      for(int i=1; i<=nodenum; ++i)
          dist[i] = maxint;
      dist[source] = 0;
      for(int i=1; i<=edgenum; ++i)
      {
          cin >> edge[i].u >> edge[i].v >> edge[i].weight;
          if(edge[i].u == source)          //注意这里设置初始情况
              dist[edge[i].v] = edge[i].weight;
      }
  }
  
  // 松弛计算
  void relax(int u, int v, int weight)
  {
      if(dist[v] > dist[u] + weight)
          dist[v] = dist[u] + weight;
  }
  
  bool Bellman_Ford()
  {
      for(int i=1; i<=nodenum-1; ++i)
          for(int j=1; j<=edgenum; ++j)
              relax(edge[j].u, edge[j].v, edge[j].weight);
      bool flag = 1;
      // 判断是否有负环路
      for(int i=1; i<=edgenum; ++i)
          if(dist[edge[i].v] > dist[edge[i].u] + edge[i].weight)
          {
              flag = 0;
              break;
          }
      return flag;
  }
  int main()
  {
      //freopen("input3.txt", "r", stdin);
      init();
      if(Bellman_Ford())
          for(int i = 1 ;i <= nodenum; i++)
              cout << dist[i] << endl;
      return 0;
  }