Dijkstra和Bellman_Ford都是从一个起点出发,计算到各顶点的距离。不过有时候需要求对所有成对定点的最短距离。引入了Floyd算法。
Floyd算法考虑的是一条最短路径上的中间结点。假设图中有一个定点x,对于u到v的最短路径,该路径可能经过x,也可能不经过x。设所有结点集合为S
(1)、不经过x:那么该路径只会经过S-{x}中的结点。
(2)、经过x:此时,将路径分为(u,x)和(x,v)。且这两个路径也是最短路径。很显然这两个路径也不会经过x,故也只将S-{x}最为途径点。
将图中所有点S考虑在内,从u到v的最短路径肯定是上面两种情况中路径最小的一个。
故:dist(u,v,S) = min ( dist(u,v,S-{x}), dist(u,x,S-{x})+dist(x,v,S-{x}) )
对上式进行简单的修改,设S(k)={0,1,2,。。。,k},表示总的结点,dist(u,v,k)表示考虑第0第到k个结点的u到v最短路径。则上式可以写为:dist(u,v,k) = min ( dist(u,v,k-1), dist(u,k,k-1)+dist(k,v,k-1) ).(k表示第k个结点)
进一步简化:我们可知dist(u,k,k-1)是考虑起点到第k-1个顶点,计算u到k的最短路径,dist(u,k,k)是考虑起点到第k个顶点,计算u到k的最短路径。我们看到由于这两个路径中起点或终点有一个为k,在将k考虑为是否经过没有意义。因此式子可以写成:
dist(u,v) = min ( dist(u,v), dist(u,k)+dist(k,v) ).
通过递归调用即可求得最终的dist(u,v).且在计算过程中可以保存k值,即经过的点,用来还原最短路径。
C++代码如下:
#include <iostream>
#include <vector>
#define INF 999999
using namespace std;
void floyd(int n, int adj[][7], int via[][7])
{
for(int k=0; k<n; k++)
{
for(int i=0; i<n; i++)
{
for(int j=0; j<n; j++)
{
if(adj[i][j]>adj[i][k]+adj[k][j])
{
via[i][j]=k;
adj[i][j]=adj[i][k]+adj[k][j];
}
}
}
}
}
//计算a到b的最短路径,保存在path中
void reconstruct(int a, int b, vector<int>& path, int via[][7])
{
if(via[a][b]==-1)
{
path.push_back(a);
if(a!=b)
path.push_back(b);
}
else
{
int w=via[a][b];
reconstruct(a,w,path,via);
path.pop_back();
reconstruct(w,b,path,via);
}
}
int main()
{
//v:结点个数,m:边数
int v=7, m=9;
//边之间的权值,没有边相连权值为无穷大
int adj[7][7];
//存储途经点
int via[7][7];
//初始化为无穷大
memset(adj,INF,sizeof(adj));
//初始化为-1
memset(via,-1,sizeof(via));
for(int i=0; i<v; i++)
{
//自身到自身的距离为0
adj[i][i]=0;
}
for(int i=0; i<m; i++)
{
int a=0,b=0,c=0;
cin>>a>>b>>c;
adj[a-1][b-1]=c;
adj[b-1][a-1]=c;
}
floyd(v, adj, via);
vector<int> path;
reconstruct(0, 5, path,via);
for(vector<int>::iterator iter=path.begin(); iter!=path.end(); iter++)
{
cout<<(*iter)+1<<" ";
}
cout<<endl;
}