$Floyed-Warshall$算法
定义：
简称$Floyed$(弗洛伊德)算法，是最简单的最短路径算法，可以计算图中任意两点间的最短路径。$Floyed$的时间复杂度是$O (N^3)$，适用于出现负边权的情况。
算法描述：
$ps$：以下没有特别说明的话：$dis[u][v] $表示从 $u$ 到$ v $最短路径长度。$w[u][v]$ 表示连接 $u$，$v$ 的边的长度。
初始化：点$u$、$v$如果有边相连，则$dis[u][v]=w[u][v]$。
如果不相连则$dis[u][v]=INF$
for (k = 1; k <= n; k++)
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
if (dis[i][j] >dis[i][k] + dis[k][j])
dis[i][j] = dis[i][k] + dis[k][j];算法&思想：
三层循环，第一层循环中间点k，第二第三层循环起点终点$i$、$j$，算法的思想很容易理解：如果点i到点k的距离加上点k到点j的距离小于原先点i到点j的距离，那么就用这个更短的路径长度来更新原先点$i$到点$j$的距离。
在上图中，因为$dis[1][3]+dis[3][2]<dis[1][2]$，所以就用$dis[1][3]+dis[3][2$]来更新原先1到2的距离。
我们在初始化时，把不相连的点之间的距离设为一个很大的数，不妨可以看作这两点相隔很远很远，如果两者之间有最短路径的话，就会更新成最短路径的长度。Floyed算法的时间复杂度是O(N3)。
$Dijkstra$算法
定义：
用来计算从一个点到其他所有点的最短路径的算法，是一种单源最短路径算法。也就是说，只能计算起点只有一个的情况。
（$ps$：有了负权值$dij$这种算法就不能用了，为什么呢？
因为这种算法是贪心的思想，每次松弛的的前提是用来松弛这条边的最短路肯定是最短的。
然而有负权值的时候这个前提不能得到保证，所以$dij$这种算法不能成立。）
思路：
算法分析&思想讲解：
从起点到一个点的最短路径一定会经过至少一个“中转点”（例如下图1到5的最短路径，中转点是2，特殊地，我们认为起点1也是一个“中转点”）。
显而易见，如果我们想求出起点到一个点的最短路径，那我们必然要先求出中转点的最短路径（例如我们必须先求出点2 的最短路径后，才能求出从起点到5的最短路径）。
我们把点分为两类，一类是已确定最短路径的点，称为“白点”，另一类是未确定最短路径的点，称为“蓝点”。如果我们要求出一个点的最短路径，就是把这个点由蓝点变为白点。从起点到蓝点的最短路径上的中转点在这个时刻只能是白点。
Dijkstra的算法思想，就是一开始将起点到起点的距离标记为0，而后进行$n$次循环，每次找出一个到起点距离$dis[u]$最短的点$u$，将它从蓝点变为白点。随后枚举所有的蓝点$v[i]$，如果以此白点为中转到达蓝点$v[i]$的路径$dis[u]+w[u][vi]$更短的话，这将它作为$v[i]$的“更短路径”$dis[v[i]]$（此时还不确定是不是$v[i]$的最短路径）。
就这样，我们每找到一个白点，就尝试着用它修改其他所有的蓝点。中转点先于终点变成白点，故每一个终点一定能够被它的最后一个中转点所修改，而求得最短路径。
实现
（1）朴素算法
给出代码：
void dij(int st){
memset(dis,INF,sizeof(dis));
for(int i=head[st];i;i=e[i].nxt) dis[e[i].v]=e[i].w;
dis[st]=0,now=st;
while(!vis[now]){
vis[now]=1,minn=INF;
for(int i=head[now],w,v;i;i=e[i].nxt){
v=e[i].v;w=e[i].w;
if(!vis[v]&&dis[v]>dis[now]+w)dis[v]=dis[now]+w;
}
for(int i=1;i<=n;i++){
if(!vis[i]&&dis[i]<minn){
minn=dis[i],now=i;
}
}
}
}（2）堆优化
我们通过学习朴素$Dij$算法，明白$Dij$算法的实现需要从头到尾扫一遍点找出最小的点然后进行松弛。这个扫描操作就是坑害朴素$DIJ$算法时间复杂度的罪魁祸首。
所以我们使用小根堆，用优先队列来维护这个“最小的点”。从而大大减少$Dij$算法的时间复杂度。
前置芝士：
1.pair
$pair$是$C++$自带的二元组。我们可以把它理解成一个有两个元素的结构体。
更刺激的是，这个二元组有自带的排序方式：以第一关键字为关键字，再以第二关键字为关键字进行排序。
所以，我们用二元组的$first$位存距离，$second$位存编号即可。
typedef pair<int,int> p;
priority_queue<p,vector<p>,greater<p> >q;定义一个按pair排好的小根堆；
2.怎么往pair类型的优先队列里加元素
q.push(make_pair(first,second))实现：
我们需要往优先队列中$push$最短路长度，但是它一旦入队，就会被优先队列自动维护离开原来的位置，换言之，我们无法再把它与它原来的点对应上，也就是说没有办法形成点的编号到点权的映射。
我们用$pair$解决这个问题，参考前置芝士。
代码：
void dijkstra(){
for(int i=1;i<=n;i++)dis[i]=INF;
dis[s]=0;q.push(make_pair(0,s));
while(!q.empty()){
int u=q.top().second;q.pop();
if(vis[u]) continue; vis[u]=1;
for(int i=head[u];i;i=e[i].next){
int v=e[i].v;
if(dis[v]>dis[u]+e[i].w){
dis[v]=dis[u]+e[i].w;
q.push(make_pair(dis[v],v));
}
}
}
}$Bellman-Ford$算法
不会……
$SPFA$算法
关于：
$SPFA$是$Bellman-Ford$算法的一种队列实现，减少了不必要的冗余计算。
主要思想：
初始时将起点加入队列。每次从队列中取出一个元素，并对所有与它相邻的点进行修改，若某个相邻的点修改成功，则将其入队。直到队列为空时算法结束。
这个算法，简单的说就是队列优化的$bellman-ford$，利用了每个点不会更新次数太多的特点发明的此算法。
$SPFA$ 在形式上和广度优先搜索非常类似，不同的是广度优先搜索中一个点出了队列就不可能重新进入队列，但是$SPFA$中一个点可能在出队列之后再次被放入队列，也就是说一个点修改过其它的点之后，过了一段时间可能会获得更短的路径，于是再次用来修改其它的点，这样反复进行下去。
（$ps$：为什么$SPFA$可以处理负边：
因为在SPFA中每一个点松弛过后说明这个点距离更近了，所以有可能通过这个点会再次优化其他点，所以将这个点入队再判断一次，而$Dijkstra$中是贪心的策略，每个点选择之后就不再更新，如果碰到了负边的存在就会破坏这个贪心的策略就无法处理了。）
代码：
void spfa() {
for(int i=1; i<=n; i++) dis[i]=INF;
q.push(s); vis[s]=1;dis[s]=0;int u,v;
while(!q.empty()) {
u=q.front();q.pop();vis[u]=0;
for(int i=head[u]; i; i=e[i].nxt) {
v=e[i].v;
if(dis[v]>dis[u]+e[i].w) {
dis[v]=dis[u]+e[i].w;
if(!vis[v]) {
vis[v]=1;q.push(v);
}
}
}
}
}