最短路

$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);
				}
			}
		}
	}
}