转自师哥博客
嘻嘻嘻
一、floyd
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号顶点的路程之和。其中i是1n循环，j也是1n循环，代码实现如下。
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];
这段代码的基本思想就是：最开始只允许经过1号顶点进行中转，接下来只允许经过1和2号顶点进行中转……允许经过1~n号所有顶点进行中转，求任意两点之间的最短路程。与上面相同
3.代码模板：
#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;
}
二、dijkstra
五.Dijkstra(迪杰斯特拉)
1.算法介绍：
Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法，Dijkstra 算法，用于对有权图进行搜索，找出图中两点的最短距离，既不是DFS搜索，也不是BFS搜索。
把Dijkstra 算法应用于无权图，或者所有边的权都相等的图，Dijkstra 算法等同于BFS搜索。
以这个例子演示
假设起点是D
有两个集合，一个是没被标记的U，另一个是已被标记的集合S，起初只有D点在集合S里
首先找所有与D相连的点中距离最短的，发现是C，然后把C放在集合S里，再找U集合里与起点相连的最短距离，然后标记，直至所有的点都被标记
用图来演示如下
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;
}
三、Bellman-Ford(贝尔曼-福特)
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;
}
转载自：https://blog.csdn.net/Akatsuki__Itachi/article/details/76082494（嘻嘻嘻）
四、SPFA
适用范围：给定的图存在负权边，这时类似Dijkstra等算法便没有了用武之地，而Bellman-Ford算法的复杂度又过高，SPFA算法便派上用场了。 我们约定有向加权图G不存在负权回路，即最短路径一定存在。当然，我们可以在执行该算法前做一次拓扑排序，以判断是否存在负权回路，但这不是我们讨论的重点。
实现方法：
建立一个队列，初始时队列里只有起始点，再建立一个表格记录起始点到所有点的最短路径（该表格的初始值要赋为极大值，该点到他本身的路径赋为0）。然后执行松弛操作，用队列里有的点作为起始点去刷新到所有点的最短路，如果刷新成功且被刷新点不在队列中则把该点加入到队列最后。重复执行直到队列为空。
判断有无负环：
如果某个点进入队列的次数超过N次则存在负环（SPFA无法处理带负环的图）
代码：
int pnt[MAXN][MAXN];
int map[MAXN][MAXN]; //map[i,j]为初始输入的i到j的距离，并且map[i,i]=0;未知的map[i,j]=INF;
int dis[MAXN];
char vst[MAXN];
int SPFA(int n,int s)
{
int i, pri, end, p, t;
memset(vst, 0, sizeof(vst));
for (i=1; i<=n; i++)
dis[i] = INF;
dis[s] = 0;
vst[s] = 1;
Q[0] = s; pri = 0; end = 1;
while (pri < end)
{
p = Q[pri];
for (i=1; i<=pnt[p][0]; i++)
{
t = pnt[p][i];
//先释放，释放成功后再判断是否要加入队列
if (dis[p]+map[p][t] < dis[t])
{
dis[t] = dis[p]+map[p][t];
if (!vst[t])
{
Q[end++] = t;
vst[t] = 1;
}
}
}
vst[p] = 0;
pri++;
}
return 1;
}
