1.介绍
floyd算法只有五行代码，代码简单，三个for循环就可以解决问题，所以它的时间复杂度为O(n^3)，可以求多源最短路问题。
2.思想：
Floyd算法的基本思想如下：从任意节点A到任意节点B的最短路径不外乎2种可能，1是直接从A到B，2是从A经过若干个节点X到B。所以，我们假设Dis(AB)为节点A到节点B的最短路径的距离，对于每一个节点X，我们检查Dis(AX) + Dis(XB) < Dis(AB)是否成立，如果成立，证明从A到X再到B的路径比A直接到B的路径短，我们便设置Dis(AB) = Dis(AX) + Dis(XB)，这样一来，当我们遍历完所有节点X，Dis(AB)中记录的便是A到B的最短路径的距离。
如现在只允许经过1号顶点，求任意两点之间的最短路程，只需判断e[i][1]+e[1][j]是否比e[i][j]要小即可。e[i][j]表示的是从i号顶点到j号顶点之间的路程。e[i][1]+e[1][j]表示的是从i号顶点先到1号顶点，再从1号顶点到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和2号两个顶点的情况下任意两点之间的最短路程。在只允许经过1号顶点时任意两点的最短路程的结果下，再判断如果经过2号顶点是否可以使得i号顶点到j号顶点之间的路程变得更短。即判断e[i][2]+e[2][j]是否比e[i][j]要小，代码实现为如下。
//经过1号顶点
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];
//经过2号顶点
for(i=1; i<=n; i++)
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(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];
#include <stdio.h>
#define inf 0x3f3f3f3f
int map[1000][1000];
int main()
{
int k,i,j,n,m;
//读入n和m，n表示顶点个数，m表示边的条数
scanf("%d %d",&n,&m);
//初始化
for(i=1; i<=n; i++)
for(j=1; j<=n; j++)
if(i==j)
map[i][j]=0;
else
map[i][j]=inf;
int a,b,c;
//读入边
for(i=1; i<=m; i++)
{
scanf("%d %d %d",&a,&b,&c);
map[a][b]=c;//这是一个有向图
}
//Floyd-Warshall算法核心语句
for(k=1; k<=n; k++)
for(i=1; i<=n; i++)
for(j=1; j<=n; j++)
if(map[i][j]>map[i][k]+map[k][j] )
map[i][j]=map[i][k]+map[k][j];
//输出最终的结果,最终二维数组中存的即使两点之间的最短距离
for(i=1; i<=n; i++)
{
for(j=1; j<=n; j++)
{
printf("%10d",map[i][j]);
}
printf("\n");
}
return 0;
}
1.算法介绍：
Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法，Dijkstra 算法，用于对有权图进行搜索，找出图中两点的最短距离，既不是DFS搜索，也不是BFS搜索。
把Dijkstra 算法应用于无权图，或者所有边的权都相等的图，Dijkstra 算法等同于BFS搜索。
以这个例子演示
假设起点是D
有两个集合，一个是没被标记的U，另一个是已被标记的集合S，起初只有D点在集合S里
首先找所有与D相连的点中距离最短的，发现是C，然后把C放在集合S里，再找U集合里与起点相连的最短距离，然后标记，直至所有的点都被标记
用图来演示如下
在没找到c之前 b与f与起点距离均为无穷，没有连接.
3.代码：
邻接矩阵
#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]; //初始化第i个点到起点的距离
}
visit[1]=1; //把起点放入已被标记的集合里
dis[1]=0;
int T=n-1;
while(T--) //遍历n-1个点每次找出一个顶点的最短路径
{
min=MAX;
for(j=1; j<=n; j++)
{
if(visit[j]==0&&min>dis[j]) //找与起点最短距离的点并记录标号
{
min=dis[j];
pos=j;
}
}
visit[pos]=1; //表示这个点已经走过
//更新未被标记的点中每个点到起点的最短距离，min是dis[pos]
for(j=1; j<=n; j++)
{
if(visit[j]==0&&dis[j]>min+map[pos][j])
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;
}
邻接表实现
#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++)
{
if(q[start][i].power < dis[q[start][i].end] )
dis[q[start][i].end]=q[start][i].power; //从起点开始的dis数组更新
}
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\n", 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); //输入的数据依次存到q[begin][0]、q[begin][1]里
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;
}
Dijkstra算法是处理单源最短路径的有效算法，但它局限于边的权值非负的情况，若图中出现权值为负的边，Dijkstra算法就会失效，求出的最短路径就可能是错的。这时候，就需要使用其他的算法来求解最短路径，Bellman-Ford算法就是其中最常用的一个。该算法由美国数学家理查德•贝尔曼（Richard Bellman, 动态规划的提出者）和小莱斯特•福特（Lester Ford）发明。Bellman-Ford算法的流程如下：
给定图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－ford算法的第三部分，遍历所有边，检查是否存在d（v） > d (u) + w(u,v)。因为第二部分循环的次数是定长的，所以如果存在无法收敛的情况，则肯定能够在第三部分中检查出来。比如
此时，点A的值为－2，点B的值为5，边AB的权重为5，5 > -2 + 5. 检查出来这条边没有收敛。
所以，Bellman－Ford算法可以解决图中有权为负数的边的单源最短路径问。
代码：
int N, M;
typedef struct node
{
int u, v;
int cost;
} E;
node E[N];
int dis[N], pre[N];
bool Bellman()
{
int ok;
for(int i = 1; i <= N; ++i)
dis[i] = (i == 1 ? 0 : MAX);
for(int i = 1; i <= N - 1; ++i)
{
ok=1;
for(int j = 1; j <= M; ++j)
if(dis[E[j].v] > dis[E[j].u] + E[j].cost)
{
dis[E[j].v] = dis[E[j].u] + E[j].cost;
ok=0;
}
if(ok==1)
break;
}
bool flag = 1;
for(int i = 1; i <= M; ++i) //判断有无负环
if(dis[E[i].v] > dis[E[i].u] + E[i].cost)
{
flag = 0;
break;
}
return flag;
}
int main()
{
cin>>N>>M;
for(int i = 1; i <= M; ++i)
cin>>E[i].u>>E[i].v>>E[i].cost;
if(Bellman())
cout<<dis[M];
else
cout<<"存在负";
return 0;
}
四、SPFA
粗略讲讲SPFA算法的原理，SPFA算法是1994年西安交通大学段凡丁提出
是一种求单源最短路的算法
算法中需要用到的主要变量
int n; //表示n个点，从1到n标号
int s,t; //s为源点，t为终点
int d[N]; //d[i]表示源点s到点i的最短路
int p[N]; //记录路径（或者说记录前驱）
queue q; //一个队列，用STL实现，当然可有手打队列，无所谓
bool vis[N]; //vis[i]=1表示点i在队列中 vis[i]=0表示不在队列中
几乎所有的最短路算法其步骤都可以分为两步
1.初始化
2.松弛操作
初始化： d数组全部赋值为INF（无穷大）；p数组全部赋值为s（即源点），或者赋值为-1，表示还没有知道前驱
然后d[s]=0; 表示源点不用求最短路径，或者说最短路就是0。将源点入队；
（另外记住在整个算法中有顶点入队了要记得标记vis数组，有顶点出队了记得消除那个标记）
队列+松弛操作
读取队头顶点u，并将队头顶点u出队（记得消除标记）；将与点u相连的所有点v进行松弛操作，如果能更新估计值（即令d[v]变小），那么就更新，另外，如果点v没有在队列中，那么要将点v入队（记得标记），如果已经在队列中了，那么就不用入队
以此循环，直到队空为止就完成了单源最短路的求解
SPFA可以处理负权边
定理: 只要最短路径存在，上述SPFA算法必定能求出最小值。
证明：
每次将点放入队尾，都是经过松弛操作达到的。换言之，每次的优化将会有某个点v的最短路径估计值d[v]变小。所以算法的执行会使d越来越小。由于我们假定图中不存在负权回路，所以每个结点都有最短路径值。因此，算法不会无限执行下去，随着d值的逐渐变小，直到到达最短路径值时，算法结束，这时的最短路径估计值就是对应结点的最短路径值。（证毕）
期望的时间复杂度O(ke)， 其中k为所有顶点进队的平均次数，可以证明k一般小于等于2。
判断有无负环：
如果某个点进入队列的次数超过N次则存在负环（SPFA无法处理带负环的图）
SPFA的两种写法，bfs和dfs，bfs判别负环不稳定，相当于限深度搜索，但是设置得好的话还是没问题的，dfs的话判断负环很快
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;
}
int spfa_dfs(int u)
{
vis[u]=1;
for(int k=f[u]; k!=0; k=e[k].next)
{
int v=e[k].v,w=e[k].w;
if( d[u]+w < d[v] )
{
d[v]=d[u]+w;
if(!vis[v])
{
if(spfa_dfs(v))
return 1;
}
else
return 1;
}
}
vis[u]=0;
return 0;
}