最短路问题——（最短路径）
1、只有五行的算法——Floyd-Warshall算法
下图中有4个城市8条公路，公路上的数字表示这条公路的长短。注意公路是单向的。咱们须要求出任意两个城市之间的最短路程，即任意两点之间的最短路径。
数组
首先，咱们创建一个数据结构来存储图的信息，使用一个4*4的矩阵（二维数组e）来存储。例如1号城市到2号城市的路程为2，则使e[1][2]的值为2。2号城市没法到达4号城市，则设置e[2][4]的值为∞。而且规定一个城市本身到本身的路程为0。则最初的二维数组为：数据结构
如何求任意两点之间的最短路径呢？咱们以前学习深度优先搜索和广度优先搜索求两点之间的最短路径。因此能够用搜索去求最短路径。还有没有其余方法呢？？？学习
按照生活经验，若是咱们不能从一个地方直接到另外一个地方，咱们通常会绕到其余能到那个城市的地方进行中转。这样就将∞变成了一个有限值。一样的思想，若是咱们要让任意两点（例如顶点a到顶点b）之间的路程变短，只能引入第三个点(顶点k)，并经过这个顶点中转(即a→k→b)，才有可能缩短原来从顶点a到顶点b的路程。由此咱们也能够想到，也许通过更多的点中转，顶点a到顶点b可能会更短。例如上图中从4号城市到3号城市，原始路程e[4][3]是12，若是只通过1号城市中转（4→1→3），路程将缩短至11（e[4][1]+e[1][3]=5+6=11）。细心一个可能会发现，其实1号城市到3号城市能够经过2号城市中转，使得路程缩短为5 （e[1][2]+e[2][3]=2+3=5）。全部能够同时通过1号城市和2号城市中转，使得4号城市到3号城市的路程进一步缩短为10。下面，咱们将这个问题详细的处理一下。测试
当任意两点之间不容许通过第三个点时，这些城市之间的最短路径就是初始路径，以下：优化
假如如今咱们只容许通过1号城市，求任意两个城市之间的路程？根据咱们以前的分析能够知道，咱们只须要判断 e[i][1]+e[1][j] 是否比 e[i][j] 小就能够了。e[i][1]+e[1][j]表示从 i 号城市通过1号城市中转再到 j 号城市的路程之和。e[i][j]表示从 i 号城市直接到j 号城市的路程。代码以下：3d
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
{
if(e[i][j]>e[i][1]+e[1][j])
{
e[i][j]=e[i][1]+e[1][j];
}
}
}
在只容许通过1 号城市的状况下，任意两点之间的最短路程变为：code
经过上图咱们能够很清楚的看到：在只通过1号城市中转的状况下，（3→2），（4→2），（4→3）的路程都变短了。blog
接下来，求只容许通过1号城市和2号城市的状况下任意两点之间的最短路程。不过这样该怎么作呢？？？咱们须要在只容许通过1号城市的结果下，再判断通过2号城市是否可使得i 号城市到j 号城市之间的路程变短，即判断e[i][2]+e[2][j]是否比e[i][j]要小，代码以下：it
for(i=1;i<=n;i++)//通过1号城市
{
for(j=1;j<=n;j++)
{
if(e[i][j]>e[i][1]+e[1][j])
{
e[i][j]=e[i][1]+e[1][j];
}
}
}
for(i=1;i<=n;i++)//通过2号城市
{
for(j=1;j<=n;j++)
{
if(e[i][j]>e[i][2]+e[2][j])
{
e[i][j]=e[i][2]+e[2][j];
}
}
}
在只容许通过1号和2号城市的状况下，任意两点之间的路程变为：
从图上能够看到，相比于只容许通过1号城市进行中转，此时通过1号和2号城市的中转，使得（1→3），（4→3）的路程又变短了。
与上述方法同样，咱们继续让只容许通过一、2和3号城市进行中转，求任意两点之间的最短路程。代码以下：
for(i=1;i<=n;i++)//通过1号城市
{
for(j=1;j<=n;j++)
{
if(e[i][j]>e[i][1]+e[1][j])
{
e[i][j]=e[i][1]+e[1][j];
}
}
}
for(i=1;i<=n;i++)//通过2号城市
{
for(j=1;j<=n;j++)
{
if(e[i][j]>e[i][2]+e[2][j])
{
e[i][j]=e[i][2]+e[2][j];
}
}
}
for(i=1;i<=n;i++)//通过3号城市
{
for(j=1;j<=n;j++)
{
if(e[i][j]>e[i][3]+e[3][j])
{
e[i][j]=e[i][3]+e[3][j];
}
}
}
任意两点之间的最短路程变为：
- 最后容许通过全部的城市做为中转，任意两点之间的最终的最短路程为：
通过上面的一步一步的分析，整个的算法就分析完了。整个算法过程就如上述所说，提及来麻烦，可是代码很简单，核心代码只有五行：
for(k=1;k<=n;k++)
{
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
{
if(e[i][j]>e[i][k]+e[k][j])
{
e[i][j]=e[i][k]+e[k][j];
}
}
}
}
这段代码的基本思想就是：从 i 号顶点到 j 号顶点只通过前 k 号点的最短路程。
下面是上面题的完整代码：
#include<stdio.h>
int main()
{
int e[10][10],k,i,j,n,m,t1,t2,t3;
int inf=99999999; //用inf (infinity 的缩写）存储一个咱们认为的正无穷大值
scanf("%d %d",&n,&m); //n表示顶点个数，m表示边的条数
for(i=1;i<=n;i++)//初始化
{
for(j=1;j<=n;j++)
{
if(i==j)
e[i][j]=0;
else
e[i][j]=inf;
}
}
for(i=1;i<=m;i++)//输入边
{
scanf ("%d %d %d",&t1,&t2,&t3);
e[t1][t2]=t3; //表示 t1 到 t2 的路程为 t3
}
for(k=1;k<=n;k++) //Floyd-Warshall算法
{
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
{
if(e[i][j]>e[i][k]+e[k][j])
{
e[i][j]=e[i][k]+e[k][j];
}
}
}
}
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
{
printf("%10d",e[i][j]);
}
printf("\n");
}
return 0;
}
注意：如何表示正无穷？咱们一般将正无穷定义为99999999，由于这样即便2个正无穷相加，其和仍然不超过int类型的范围。实际应用中最后估计一下最短路径的上限，只须要设置的比它大一点就能够了。例如若是有10条边，每条边不超过10的话，只须要将正无穷设置为101便可（10*10）。
上面代码输入样式为：
4 8 1 2 2 1 3 6 1 4 4 2 3 3 3 1 7 3 4 1 4 1 5 4 3 12
最终结果为：
经过这种方法咱们能够求出任意两点之间的最短路程。时间复杂度为O（N³）。若是时间复杂度要求不高，可使用这个方法，也能够用它来求指定两点之间的最短路程或者指定一点到其他个点的最短路程。固然还有更快的Dijkstra算法。
2、Dijkstra算法——同过边实现松弛
经过此算法咱们来学习指定一个点（源点）到其他个点的最短路径，例如，求下图中的1号顶点到二、三、四、五、6号顶点的最短路径。
与Kloyd-Warshall算法同样，仍然使用二维数组e来存储顶点之间边的关系，初始值为：
此时咱们还须要一个一维数组dis 来存储1 号顶点到其他个点的初始路程。以下：
咱们将此时dis 数组中的值称为最短路径的“估计值”。
既然是求1号顶点到其他各个顶点的最短路程，那就先找一个离1号顶点最近的顶点。经过数组dis，可知当前离1号顶点最近的是2号顶点。当选择了2号顶点后，dis[2]的值就已经从“估计值"变为了“肯定值”，即1号顶点到2号顶点的最短路程就是当前dis[2]值。为何呢? 你想啊，目前离1号顶点最近的是2号顶点，而且这个图全部的边都是正数，那么确定不可能经过第三个顶点中转，使得1号顶点到2号顶点的路程进一步缩短了。由于1号顶点到其余顶点的路程确定没有1号到2号顶点短。
既然选了2号顶点，接下来再来看2号顶点有哪些出边，有2→3和2→4这两条边。先讨论经过2→3这条边可否让1号顶点到3号顶点的路程变短，也就是说如今来比较dis[3]和dis[2]+e[2][3]的大小。其中dis[3]表示1号顶点到3号顶点的路程:；dis[2]+e[2][3]中 dis[2]表示1号顶点到2号顶点的路程，e[2][3]表示2→3这条边。因此dis[2]+e[2][3]就表示从1号顶点先到2号顶点，再经过2→3这条边，到达3号顶点的路程。
从中咱们能够发现dis[3]=12，dis[2]+e[2][3]=1+9 =10, dis[3]>dis[2]+e[2][3]，所以dis[3]要更新为10。这个过程有个专业术语叫作“松弛”，1 号顶点到3号顶点的路程即dis[3]，经过2→3这条边松弛成功。这即是Dijkstra算法的主要思想：经过“边”来松弛1号顶点到其他各个顶点的路程。
同理，经过2→4（e[2][4]），能够将dis[4]的值从∞松弛为4。
刚才咱们对2号顶点全部的出边进行了松弛。松弛完毕后dis 数组为：
接下来，继续在剩下的三、四、5和6号顶点中，选出离1号顶点最近的顶点。经过上面更新过的dis数组，当前离1号顶点最近的是4号顶点。此时，dis[4]的值已经从“估计值”变为了“肯定值”。下面继续对4号顶点的全部出边(4→3，4→5和4→6)用刚才的方法进行松弛。松驰完毕以后dis数组为:
继续在剩下的三、5和6号顶点中，选出离1号顶点最近的顶点，此次选择3号顶点。此时，dis[3]的值已经从“估计值”变为了“肯定值”。对3号顶点的全部出边(3→5) 进行松弛。松弛完毕以后dis 数组为:
继续在剩下的5和6号顶点中，选出离1号顶点最近的顶点，此次选择5号顶点。此时，dis[5]的值已经从“估计值”变为了“肯定值”。对5号顶点的全部出边(5>4) 进行松弛。松弛完毕以后dis数组为:
最后对6号顶点的全部出边进行松弛。由于这个例子中6号顶点没有出边，所以不用处理。到此，dis 数组中全部的值都已经从“估计值”变为了“肯定值”。
最终dis 数组以下，这即是1号顶点到其他各个顶点的最短路径。
OK，如今来总结一下刚才的算法。算法的基本思想是:每次找到离源点(上面例子的源点就是1号顶点)最近的一个顶点，而后以该顶点为中心进行扩展，最终获得源点到其他全部点的最短路径。基本步骤以下:
1.将全部的顶点分为两部分：已知最短路程的顶点集合P和未知最短路径的顶点集合Q。最开始，已知最短路径的顶点集合P中只有源点一个顶点。咱们这里用一个book数组来记录哪些点在集合P中。例如对于某个顶点i，若是book[i]为1，则表示这个顶点在集合P中，若是book[i]为0则表示这个顶点在集合Q中。
2.设置源点s到本身的最短路径为0即dis[s]=0。若存在有源点能直接到达的顶点i，则把dis[i]设为e[s][i]。同时把全部其余(源点不能直接到达的)顶点的最短路径设为∞。
3. 在集合Q的全部顶点中选择一个离源点s最近的顶点u (即dis[u]最小) 加入到集合P。并考察全部以点u为起点的边，对每一条边进行 松弛操做。例如存在一条从u到v的边，那么能够经过将边u→v添加到尾部来拓展一条从s到v的路径，这条路径的长度是dis[u]+e[u][v]。 若是这个值比目前已知的dis[v]的值要小，咱们能够用新值来替代当前dis[v]中的值。
4.重复第3步， 若是集合Q为空，算法结束。最终dis数组中的值就是源点到全部顶点的最短路径。
完整的Dijkstra算法代码以下:
#include<stdio.h>
int main()
{
int e[10][10],dis[10],book[10];
int i,j,n,m,t1,t2,t3,u,v ,min;
int inf=99999999;
scanf("%d %d",&n,&m);//n表示顶点个数，m表示边的条数
for(i=1;i<=n;i++)//初始化
{
for(j=1;j<=n;j++)
{
if(i==j) e[i][j]=0;
else e[i][j]=inf;
}
}
for(i=1;i<=m;i++)//输入边
{
scanf("%d %d %d",&t1,&t2,&t3);
e[t1][t2]=t3;//顶点 t1 到顶点 t2 的路程
}
for(i=1;i<=n;i++)//源点到各个顶点的初始路程
dis[i]=e[1][i];
for(i=1;i<=n;i++)//book数组初始化
book[i]=0;
book[1]=1;
//核心语句-----------------------
for(i=1;i<=n-1;i++)
{
min=inf;
for(j=1;j<=n;j++)//找离源点最近的点
{
if(book[j]==0&&dis[j]<min)
{
min=dis[j];
u=j;
}
}
book[u]=1;//标记已经肯定过
for(v=1;v<=n;v++)
{
if(e[u][v]<inf)//对全部以点v 为起点的边进行松弛
{
if(dis[v]>dis[u]+e[u][v])
dis[v]=dis[u]+e[u][v];
}
}
}
//------------------------------
for(i=1;i<=n;i++)
printf("%d ",dis[i]);
return 0;
}
测试样例： 6 9 1 2 1 1 3 12 2 3 9 2 4 3 3 5 5 4 3 4 4 5 13 4 6 15 5 6 4 运行结果： 0 1 8 4 13 17
- Bellman-Ford——解决负权边
开始说这个算法以前，先来了解一下什么是负权边？负权边顾名思义边的权值为负，一开始咱们讲的Floyd-Warshall算法不能解决“负权回路”，由于带有“负权回路”的图没有最短路径。例以下面这个图，每走一圈路程就会缩短一次，永远找不到最短路径。不过若是不是回路，Floyd能够解决负权边问题。
上述的Dijkstra算法不能解决负权边的问题。下面咱们要学习一个代码很是简单的算法。核心代码只有四行，而且能够解决负权边的问题。直接上代码：
for( k=1; k<=n-1; k++)
for( i=1; i<=m; i++)
if( dis[v[i]] > dis[u[i]] + w[i])
dis[v[i]] = dis[u[i]] + w[i];
上面的代码中，外循环一共循环了 n-1 次(n为顶点的个数)，内循环循环了m次(m为边的个数)，即枚举每一条边。dis 数组的做用与Dijkstra算法同样， 是用来记录源点到其他各个顶点的最短路径。u、v和w三个数组是用来记录边的信息。例如第i条边存储在u[i]、v[i]和w[i]中，表示从顶点u[i]到顶点v[i]这条边(u[i]→v[i]) 权值为w[i]. :
if( dis[v[i]] > dis[u[i]] + w[i] )
dis[v[i]] = dis[u[i]] + w[i];
上面这两行代码的意思是：看看可否经过u[i]→v[i] (权值为w[i]) 这条边，使得1号顶点到v[i]号顶点的距离变短。即1号顶点到u[i]号顶点的距离 ( dis[u[i]] ) 加上u[i]→v[i] 这条边 (权值为w[i]) 的值是否会比原先1号顶点到 v[i] 号顶点的距离 (dis[v[i]]) 要小。这一点其实与Djkstra的“松弛”操做是同样的。如今咱们要把全部的边都松弛一遍，代码以下：
for( i=1; i<=m; i++)
if( dis[v[i]] > dis[u[i]] + w[i] )
dis[v[i]] = dis[u[i]] + w[i];
把每一条边都松弛以后呢？会变成什么？举个例子：
求1号顶点到其他各个顶点的最短路径。
和Dijkstra算法思想同样，用一个dis数组存储1号顶点到全部顶点的距离。
上方右图中每一个顶点旁的值(带下划线的数字)为该顶点的最短路“估计值”(当前1号顶点到该顶点的距离)，即数组dis中对应的值。根据边给出的顺序,先来处理第1条边 “2 3 2”，即判断dis[3]是否大于dis[2]+2.此时dis[3]是∞, dis[2]是∞，所以dis[2]+2也是∞,因此经过“2 3 2”这条边不能使dis[3]的值变小，松弛失败。
同理，继续处理第2条边“1 2 -3”，咱们发现dis[2]大于dis[1]+(-3)，经过这条边可使dis[2]的值从 ∞变为-3，所以松弛成功。用一样的方法处理剩下的每一 条边。对全部的边松弛一遍后的结果以下。
接下来继续对全部边进行松弛，松弛方式和以前同样。
咱们能够发现，第1轮在对全部的边进行松弛以后，获得的是从1号顶点“只能通过一条边'到达其他各顶点的最短路径长度。第2轮在对全部的边进行松弛以后，获得的是从1号顶点“最多通过两条边”到达其他各顶点的最短路径。若是进行k轮的话，获得的就是1号顶点“最多通过k条边”到达其他各顶点的最短路径长度。那么到底须要进行多少轮呢?
答案是n-1轮，由于在一个含有n 个顶点的图中，任意两个顶点之间的最短路径最多包含n-1条边。（注意！！！最短路径是一个不包含回路的路径。），也就是说最多进行n-1次松弛
因此，Bellman-Ford算法就是：对全部边进行n-1次松弛的操做。完整代码以下：
#include<stdio.h>
int main()
{
int dis[10],i,k,n,m,u[10],v[10],w[10];
int inf=99999999;
scanf("%d %d",&n,&m);//n 表示顶点个数，m表示边的条数
for(i=1;i<=m;i++)//输入边
scanf("%d %d %d",&u[i],&v[i],&w[i]);//表示顶点u[i]到顶点v[i]的权值为w[i]
for(i=1;i<=n;i++)//初始化 ,1号顶点到其他各个顶点的初始路程
dis[i]=inf;
dis[1]=0;
for(k=1;k<=n-1;k++)//核心语句
{
for(i=1;i<=m;i++)
{
if(dis[v[i]]>dis[u[i]]+w[i])
dis[v[i]]=dis[u[i]]+w[i];
}
}
for(i=1;i<=n;i++)
printf("%d ",dis[i]);
return 0;
}
测试样例： 5 5 2 3 2 1 2 -3 1 5 5 4 5 2 3 4 3 运行结果： 0 -3 -1 2 4
咱们还能够对其进行优化。以前咱们说过，最多松弛n-1次，其实有时候根本不须要那么屡次，例如此题三次就完成了。所以咱们能够添加一个一维数组来备份dis数组,若是在新一轮松弛中dis数组没有发生变化，就能够直接跳出循环了，另外，Bellman-Ford算法还能够检测一个图是否含有“负权回路“，在进行了n-1次松弛以后，仍然能够继续松弛，就能够说明此图必然存在负权回路，下面咱们给出优化以及检测负权回路的完整代码：
#include<stdio.h>
int main()
{
int dis[10],i,k,n,m,u[10],v[10],w[10],ba[10],check,flag;
int inf=99999999;
scanf("%d %d",&n,&m);//n 表示顶点个数，m表示边的条数
for(i=1;i<=m;i++)//输入边
scanf("%d %d %d",&u[i],&v[i],&w[i]);//从顶点u[i]到顶点v[i]的权值为w[i];
for(i=1;i<=n;i++)//dis初始化 ,1号顶点到其他各个顶点的初始路程
dis[i]=inf;
dis[1]=0;
for(k=1;k<=n-1;k++)//核心语句
{
for(i=1;i<=n;i++)//将dis数组备份至ba数组中
{
ba[i]=dis[i];
}
for(i=1;i<=m;i++)//每一条边进行一轮松弛
{
if(dis[v[i]]>dis[u[i]]+w[i])
dis[v[i]]=dis[u[i]]+w[i];
}
check=0; //松弛完毕后检测dis 数组是否更新；
for(i=1;i<=n;i++)
{
if(ba[i]!=dis[i])
{
check=1;
break;
}
}
if(check==0)//若是dis数组没有更新，松弛结束，退出循环
break;
}
flag=0; //检测负权回路
for(i=1;i<=m;i++)
{
if(dis[v[i]]>dis[u[i]]+w[i])
{
flag=1;
}
}
if(flag==1)
printf("此图含有负权回路");
else
{
for(i=1;i<=n;i++)
printf("%d ",dis[i]);
}
return 0;
}