一、只有五行的算法——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 号城市的路程。代码如下：
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 号城市的情况下，任意两点之间的最短路程变为：
通过上图我们可以很清楚的看到：在只经过1号城市中转的情况下，（3→2），（4→2），（4→3）的路程都变短了。
接下来，求只允许经过1号城市和2号城市的情况下任意两点之间的最短路程。不过这样该怎么做呢？？？我们需要在只允许经过1号城市的结果下，再判断经过2号城市是否可以使得i 号城市到j 号城市之间的路程变短，即判断e[i][2]+e[2][j]是否比e[i][j]要小，代码如下：
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）的路程又变短了。
与上述方法一样，我们继续让只允许经过1、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算法。
二、Dijkstra算法——同过边实现松弛
通过此算法我们来学习指定一个点（源点）到其余个点的最短路径，例如，求下图中的1号顶点到2、3、4、5、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 数组为：
接下来，继续在剩下的3、4、5和6号顶点中，选出离1号顶点最近的顶点。通过上面更新过的dis数组，当前离1号顶点最近的是4号顶点。此时，dis[4]的值已经从“估计值”变为了“确定值”。下面继续对4号顶点的所有出边(4→3，4→5和4→6)用刚才的方法进行松弛。松驰完毕之后dis数组为:
继续在剩下的3、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;
}
1917
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
