四种常用最短路径算法模板

最短路径算法中，有四种算法是最常见的，分别是Dijkstra算法，Floyd算法，Bellman-Ford算法和SPFA算法。

Dijkstra算法，求单源最短路径最稳定的一个算法，算法复杂度为O（n2），但可以通过队列优化。下面列出的模板是最原始的Dijkstra算法。以需要求的源为中心，向四周扩散，第一次求出的是与源直接相连接的点的距离。求出这些距离中的最短距离，然后通过这个点将与它相连接的点的最短距离更新，然后再求出现在的最短距离，如此这样下去，直到所有的点都已经被遍历过为止。已经求出最短距离的点不在参与更新。具体模板如下(以POJ3268为例）:

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <map>
using namespace std;
#define INF 0x7ffffff
#define eps 1e-8
#define sgn(a) (a>eps)-(a<-eps)
#define LL long long
#define out(v) cerr << #v << ": " << (v) << endl
#define SZ(v) ((int)(v).size())
const int maxint = -1u>>1;20 int n,m,x;
const int maxn = 1111;
int dist[maxn];
int dist2[maxn];
int d[maxn][maxn];
bool flag[maxn];

void Dijkstra(int x)
{
memset(flag,false,sizeof(flag));
for(int i=1;i<=n;++i)
{
dist[i] = d[x][i];
}
flag[x] = true;
dist[x] = 0;

for(int i=2;i<=n;++i)
{
//寻找没有标记而且dist值最小的点
int u = 1;
int mindis = maxint;
for(int j=1;j<=n;++j)
{
if(!flag[j] && dist[j] < mindis)
{
mindis = dist[j];
u = j;
}
}
flag[u] = true;
for(int j=1;j<=n;++j)
{
if(!flag[j] && d[u][j] < maxint)
{
dist[j] = min(dist[j],dist[u] + d[u][j]);
}
}
}
}

int main()
{
while(scanf("%d%d%d",&n,&m,&x) != EOF)
{
int a,b,len;
for(int i=1;i<=n;++i)
{
for(int j=1;j<=n;++j)
{
d[i][j] = maxint;
}
}
for(int i=1;i<=m;++i)
{
scanf("%d%d%d",&a,&b,&len);
d[a][b] = len;
}
Dijkstra(x);
for(int i=1;i<=n;++i) dist2[i] = dist[i];
for(int i=1;i<=n;++i)
{
for(int j=i+1;j<=n;++j)
{
swap(d[i][j],d[j][i]);
}
}
Dijkstra(x);
int ans = 0;
for(int i=1;i<=n;++i)
{
ans = max(ans,dist[i] + dist2[i]);
}
printf("%d\n",ans);
}
return 0;
}

Floyd算法其实是Floyd-Warshall算法的简称。分以下两步进行。

1，从任意一条单边路径开始。所有两点之间的距离是边的权，如果两点之间没有边相连，则权为无穷大。

2，对于每一对顶点 u 和 v，看看是否存在一个顶点 w 使得从 u 到 w 再到 v 比已知的路径更短。如果是更新它。

Floyd算法是一种动态规划算法，稠密图效果最佳，边权可正可负。此算法简单有效，由于三重循环结构紧凑，对于稠密图，效率要高于执行|V|次Dijkstra算法。
具体模板如下所示（以POJ2240为例）:

/*
* Author: xiagenyuan
* Created Time:  2013/5/1 21:03:44
* File Name: D:\ACMICPC\20130501\POJ2240.cpp
*/
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <string>
#include <algorithm>
#include <queue>
#include <vector>
#include <map>
using namespace std;
#define eps 1e-8
#define sgn(a) (a>eps)-(a<-eps)
#define LL long long
const int maxint = -1u>>1;
const int maxn = 33;
int n,m;
map<string,int> mp;//用来为名字是字符串的点对应数字
double ra[maxn][maxn]; //存取两点间的的路径

void Floyd()//对临接表进行Floyd处理
{
for(int k=1;k<=n;++k)
{
for(int i=1;i<=n;++i)
{
for(int j=1;j<=n;++j)
{
if(ra[i][j] < ra[i][k]*ra[k][j])
{
ra[i][j] = ra[i][k]*ra[k][j];
}
}
}
}
}

int main()
{
int cas = 1;
while(scanf("%d",&n) != EOF && n)
{
mp.clear();
string name;
for(int i=1;i<=n;++i)
{
cin>>name;
mp[name]=i;
}
scanf("%d",&m);
string name1,name2;
double rate;
memset(ra,1,sizeof(ra));
for(int i=1;i<=m;++i)
{
cin>>name1>>rate>>name2;
ra[mp[name1]][mp[name2]]= rate;
}
Floyd();
bool flag = false;
for(int i=1;i<=n;++i)
{
if(ra[i][i] > 1)
{
flag = true;
break;
}
}
if(flag) printf("Case %d: Yes\n",cas);
else printf("Case %d: No\n",cas);
cas++;
}
return 0;
}

Bellman-Ford算法

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

2、对于每一条边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
中记录的就是源点s到各顶点的最短路径长度。

具体模板如下所示：

/*
* Author: xiagenyuan
* Created Time:  2013/5/1 21:39:36
* File Name: C:\Users\Genyuan\Desktop\图论系列模板\Bellman-Ford.cpp
*/
//模板未进行验证
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <string>
#include <algorithm>
#include <queue>
#include <vector>
#include <map>
using namespace std;
#define eps 1e-8
#define sgn(a) (a>eps)-(a<-eps)
#define LL long long
const int maxint = 9999999;
const int maxnum = 100;
struct edge
{
int u,v;//每条边的起点和终点
int weight;//边的权值
};
edge e[maxnum];//保存所有边的值
int dist[maxnum]; //保存节点到源点的最短距离
int n,m,x; //节点数量，边的数量，源点

//读入数据，初始化图
void init()
{
while(scanf("%d%d%d",&n,&m,&x) != EOF)
{
for(int i=1;i<=n;++i) dist[i] = maxint;
dist[x] = 0;
for(int i=1;i<m;++i)
{
scanf("%d%d%d",&e[i].u,&e[i].v,&e[i].weight);
if(e[i].u == x) dist[e[i].v] = e[i].weight;
}
}
}
//松弛计算
void relax(int u,int v,int weight)
{
dist[v] = min(dist[v],dist[u]+weight);
}

bool BellmanFord()
{
for(int i=1;i<n-1;++i)
{
for(int j=1;j<=m;++j)
{
relax(e[j].u,e[j].v,e[j].weight);
}
}
bool flag = true;
for(int i=1;i<m;++i)
{
if(dist[e[i].v] > dist[e[i].u]+e[i].weight)
{
flag = false;
break;
}
}
return flag;
}

int main()
{
init();
if(BellmanFord())
{
for(int i=1;i<=m;++i) cout<<dist[i]<<" ";
cout<<endl;
}
else cout<<"No"<<endl;
return 0;
}

SPFA算法其实就是Bellman-Ford算法，只是它用队列进行了优化。用队列进行优化有三种形式：

1、简单地用队列进行存储。

2、SLF：Small Label First 策略，设要加入的节点是j，队首元素为i，若dist(j)<dist(i)，则将j插入队首，否则插入队尾。

3、LLL：Large Label Last 策略，设队首元素为i，队列中所有dist值的平均值为x，若dist(i)>x则将i插入到队尾，查找下一元素，直到找到某一i使得dist(i)<=x，则将i    

    出对进行松弛操作。

以下模板是针对第一种情况（POJ3268为例）：

/*
* Author: xiagenyuan
* Created Time:  2013/5/1 22:26:23
* File Name: D:\ACMICPC\20130501\POJ3268SPFA.cpp
*/
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <string>
#include <algorithm>
#include <queue>
#include <vector>
#include <map>
using namespace std;
#define eps 1e-8
#define sgn(a) (a>eps)-(a<-eps)
#define LL long long
const int maxint = 99999999;
const int maxn = 1000 + 111;
int n,m,x;
int d[maxn][maxn];
int dist[maxn];
int dist2[maxn];
bool visited[maxn];
int que[2*maxn];

void spfa()
{
int pri = 0,end = 1;
memset(visited,false,sizeof(visited));
visited[x] = true;
for(int i=1;i<=n;++i) dist[i] = maxint;
dist[x] = 0;
que[0] = x;
while(pri < end)
{
int index = que[pri];
for(int i=1;i<=n;++i)
{
if(dist[index] + d[index][i] < dist[i])
{
dist[i] = dist[index] + d[index][i];
if(!visited[i])
{
que[end++] = i;
visited[i] = true;
}
}
}
visited[index] = false;
pri++;
}
}

int main()
{
while(scanf("%d%d%d",&n,&m,&x) != EOF)
{
int a,b,len;
for(int i=1;i<=n;++i)
{
for(int j=1;j<=n;++j)
{
d[i][j] = maxint;
}
}
for(int i=1;i<=m;++i)
{
scanf("%d%d%d",&a,&b,&len);
d[a][b] = len;
}
spfa();
for(int i=1;i<=n;++i) dist2[i]  = dist[i];
for(int i=1;i<=n;++i)
{
for(int j=i+1;j<=n;++j)
{
swap(d[i][j],d[j][i]);
}
}
spfa();
int ans = 0;
for(int i=1;i<=n;++i)
{
ans = max(ans,dist[i] + dist2[i]);
}
printf("%d\n",ans);
}
return 0;
}