简单最短路径算法

前言

图的最短路径算法主要包括：

• 有向无权图的单源最短路径
  • 宽度优先搜索算法（bfs）
• 有向非负权图的单源最短路径
  • 迪杰斯特拉算法（Dijkstra）
• 有向有权图的单源最短路径
  • 贝尔曼福特算法（Bellman-Ford）
  • 最短路径快速算法（SPFA）
• 有向有权图的多源最短路径
  • 弗洛伊德算法（Floyd）
  • 负环
  • 约翰逊算法（Johnson）
• 有向非负权图的单源k短路径：
  • 迪杰斯特拉算法（Dijkstra）
• 有向非负权图的单源汇k短路径：
  • 启发式搜索算法（A*）
    事实上k短路径可以用可持久化可并堆来做，但是我不会。
• 有向无环图的单源最短路径
  • 拓扑排序+动态规划

关于简单路径的问题：
事实上图上任意一条长度不为$?\infty$的最短路径一定是简单路径，并且任意一条长度不为$+\infty$的最长路径也一定是简单路径。显然。

我们把所有边的边权取反，这样原来的最长路径就成为了最短路径，原来的最短路就成为了现在的最长路。

约定

• 对于无权图$G$，我们认为它相当于边权全为$1$的带权图。
• 负环指的是环上所有边的边权和为负数的环，正环同理。
• 本文所说的最短路径，并不要求路径上没有重复节点，即路径上可能存在环。
  事实上最短路径上的环一定是负环或零环，零环可以舍去，因此如果图中不存在负环，则我们认为最短路径一定是简单路径
• 我们用$di{s}_{u,v}$表示图中从$u$到$v$的最短路，记作$u$到$v$的距离
• 单源最短路径指的是，起点为固定的一个点$S$，终点为图中任意点的所有最短路径。
  即单源最短路径算法要求出：$di{s}_{S,u\in V}$

宽度优先搜索算法（bfs）

bfs算法求出有向无权图上的单源最短路径。

bfs算法的过程是这样的：

• 初始，$S$与自身的距离为$0$
• 标记所有$S$的临接点，它们与$S$的距离为$1$
• 标记所有$f_u=1$的点的临接点中未被标记的点，它们与$S$的距离为$2$
• 标记所有$f_u=2$的点的临接点中未被标记的点，它们与$S$的距离为$3$
• 标记所有$f_u=3$的点的临接点中未被标记的点，它们与$S$的距离为$4$
• …
• 以此类推，直到所有点都被标记。

很容易使用归纳的方法证明bfs算法的正确性：
假设目前标记了所有$di{s}_{S,u}\le k$的点，并正确计算了其距离，显然所有$di{s}_{S,u}=k+1$的点都会在下一轮当中被扩展。

可以使用队列来维护这个过程，具体来说是：

• 首先把$S$加入队列，标记$S$
• 设目前队列的队头为$u$，把队头的所有未被标记的临接点$v$的距离更新，$f_v=f_u+1$，然后标记这些点，把它们入队
• 弹出队头
• 重复这个入队出队的过程直到队列为空

时间复杂度$O(n+m)$，其中$n$为图的点数，$m$为边数。

迪杰斯特拉算法（Dijkstra）

松弛

在一般的求解单源最短路的过程中，我们需要维护$d_u$表示当前已知的从$S$到$u$的最短路径长度，或称$d_u$为从$S$到$u$的最短路径长度的上界，即最短路径估计。初始$d_S=0,d_{u\notin S}=+\infty$

对于图中一条从$u$到$v$的有向边，其边权为$w$，我们知道在最终的最短路上一定满足$di{s}_u+w\ge di{s}_v$，因此如果当前的$d_u+w<d_v$，那我们可以从$u$走这一条边来作为当前到达$v$的最短路，说明$v$的最短路径上界为$d_u+w$而不是$d_v$，因此执行$d_v\leftarrow d_u+w$。

因此我们选出一条边$(u,v)$，尝试用$d_u$来更新$d_v$的过程叫做松弛，如果成功更新了$d_v$，那称为松弛成功，否则称为松弛失败。

松弛的过程：

	if(d[u]+w<d[v])
		d[v]=d[u]+w;

迪杰斯特拉算法

迪杰斯特拉算法是一种求解非负权图的单源最短路径的算法。

迪杰斯特拉算法的过程是这样的：

• 初始所有点都未被标记
  • 选出目前$d$最小的未被标记的点，设为$u$
  • 标记$u$
  • 用$u$的所有出边进行松弛操作
• 直到所有点都被标记，此时$d_u=di{s}_{S,u}$

证明

引理1

归纳可以证明由于边权非负，如果把被标记的点排成一个序列，则它们的$d$一定非严格递增。

引理2

$u$是从$S$到$v$的其中一条最短路上$v$的前驱的充要条件是：$di{s}_{S,u}+w=di{s}_{S,v}$
$w$表示最短路上从$u$到$v$的边的边权

引理2显然。

引理3

假设$u$是从$S$到$v$的其中一条最短路上$v$的前驱，若对边$(u,v)$进行松弛时，$d_u=di{s}_{S,u}$，则松弛后$d_v=di{s}_{S,v}$
若松弛成功，则$d_v=d_u+w=di{s}_{S,u}+w=di{s}_{S,v}$
若松弛失败，则$d_v$本来就等于$di{s}_{S,v}$

引理4

$di{s}_{u,x}+di{s}_{x,v}\ge di{s}_{u,v}$

若小于，则先沿着$u,x$的最短路走到$x$，再沿着$x,v$的最短路走到$v$，会得到比$di{s}_{u,v}$更短的最短路，与$di{s}_{u,v}$的定义矛盾

引理5

若从$u$到$v$的某条最短路经过了$x$，则$di{s}_{u,x}+di{s}_{x,v}=di{s}_{u,v}$

根据引理4，我们知道$di{s}_{u,x}+di{s}_{x,v}\ge di{s}_{u,v}$，而显然$di{s}_{u,x}+di{s}_{x,v}>di{s}_{u,v}$的话，不可能存在一条经过$x$的最短路。

迪杰斯特拉算法的正确性

归纳假设之前的所有被标记的点被标记时，都满足其最短路径估计（$d$）等于其最短路径长度（$dis$）：
设下一次被选出的点是$v$，则我们可以证明选出它时，$d_v=di{s}_{S,v}$：
找到其中一条由$S$到$v$的最短路上$v$的前驱$u$

• 若$w>0$
  则$u$一定被标记，说明$d_u=di{s}_{S,u}$松弛了$v$，根据引理3证毕。
• 否则$w=0$
  • 若至少存在一个前驱$u$满足从$u$到$v$在$S$到$v$最短路上的边不为$0$：
    则是上面的情况，证毕。
  • 否则所有的$u$到$v$在最短路上的边均为$0$：

    • 如果存在至少一个$u$被标记：
      根据引理3证毕。

    • 不存在任何一个$u$被标记：
      说明$v$尚未被任意一个最短路上的前驱更新，根据引理3可知，$d_v>di{s}_{S,v}$
      那么一定可以找到一个点$x$，使得：

      1. $x$被标记
      2. $x$在某条从$S$到$v$的最短简单路径上
      3. $x$在此条最短路径上的后继$y$未被标记。

      我们一定能选出一个这样的点，因为满足限制$1,2$的点是一定有的，而如果后继$y$不满足未被标记，说明$y$满足限制$1,2$，则我们可以令$x\leftarrow y$，由于简单路径的长度至多为$n$，因此最多跳约$n$次就会找到一个合法的点$x$：
      因此我们知道$d_x=di{s}_{S,x}$，那根据引理3我们就知道$d_y=di{s}_{S,y}$，这样我们就会知道$d_y=di{s}_{S,y}\le di{s}_{S,v}<d_v$，即$d_y<d_v$，但是$y$又未被标记，不满足引理$1$，矛盾。

证毕。

实现

#include<iostream>
#include<vector>
#include<queue>
#include<vector>
#include<functional>
#include<map>
using namespace std;
const int N=1e5;
vector<pair<int,int>>a[N+5];
int d[N+5];
bool vis[N+5];
void Dijk(int s) {
	priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>> q;
	for(auto&i:d) i=1e9;
	q.push({0,s});
	d[s]=0;
	while(!q.empty()){
		int u=q.top().second;
		q.pop();
		if(vis[u]) continue;
		vis[u]=true;
		for(auto&i:a[u]) {
			int v=i.second,w=i.first;
			if(d[v]>d[u]+w) 
				d[v]=d[u]+w,
				q.push({d[v],v});
			
		}
	}
}
int main(){
	int n,m,s;
	cin>>n>>m>>s;
	for(int i=1,u,v,w;i<=m;i++){
		cin>>u>>v>>w;
		a[u].push_back({w,v});
	}
	Dijk(s);
	for(int i=1;i<=n;i++) cout<<d[i]<<' ';
}

迪杰斯特拉算法事实上是一种优先队列bfs算法。其和朴素bfs算法的正确性保证是一致的：

• 按照距离$S$从近到远的点为前驱依次松弛，必定得到最短路。
• 由于边权非负，当前距离$d_u$最小的未被标记的点一定是未被标记点中$di{s}_{S,u}$最小的点

因此我们可以用优先队列快速求出$di{s}_{S,u}$最小的未被标记点，这样可以保证每个点的出边至多只会松弛一次，这样就有了时间复杂度保证。

如果第二点不成立，那么我们无法找到目前$di{s}_{S,u}$最小的未被标记点，我们就不能保证按照标记顺序松弛一定得到最短路，为了确保正确性，就不能保证被标记的点的出边不会再次用于松弛，因此时间复杂度分析就不成立了，也就得到了SPFA算法。

贝尔曼-福特算法（Bellman-Ford）

贝尔曼福特算法和最短路径快速算法（SPFA）都是一种用来求解有权有向图单源最短路径的算法。
由于这两种算法允许负权边的存在，因此应用范围更广一些，但是它们的时间复杂度较迪杰斯特拉也更劣。

负环

若有向图$G$中只存在非负权边，则显然$S$到任意可达点的最短路径长度为非负实数，是一个有限值。

但是如果存在这样的图：

则从$S$到$T$的路径上存在一个负环，那此时最短路径不再是简单路径，我们可以绕着负环不断行走，可以使得最短路径的权值变得越来越小，因此从$S$到$T$的最短路径长度为$?\infty$。

最短路径存在定理

从$u$到$v$存在有限长度的最短路径的充要条件是，$u$可达$v$且$u$到$v$的任何一条路径上不能存在负环。

证明：
必要性很显然，只证明充分性。
“$u$到$v$的任一路径均无负环是$u$到可达点$v$有最短路的充分条件。”
考虑其逆否命题：
“$u$到可达点$v$无有限长度的最短路，是$u$到$v$的至少一条路径上有负环的充分条件。”
假设$u$到$v$没有有限长度的最短路，说明$di{s}_{u,v}=?\infty$，由于有限条边构成的路径一定是有限长度，因此$u$到$v$的最短路经过的点数为$+\infty$。

把最短路经过的点的编号顺次排列为$a$，然后我们可以删掉$a$中所有零环，这样$a$仍然是最短路序列。
由于只有$n$个点，由于鸽巢原理，序列的前$n+1$项中至少有两个位置是相同的，设为$a_x,a_y$，则必然满足从$x$沿着对应的路径走到$y$，经过的边权和一定$<0$，说明有负环。

逆否命题成立，说明原命题成立。证毕。
（也可以直接证，但是我当时没想到，不想再改步骤了。）

这说明：有向图$G$上任意有序点对要么不可达，要么存在有限长度的最短路径的充要条件是，图$G$中没有负环。

最短路DAG与最短路径树

方便起见假设以$S$为起点可以到达任何点。

以$S$为起点，对于有向边$(u,v)$，如果满足$di{s}_{S,u}+w=di{s}_{S,v}$，就在新图上给$(u,v)$连有向边，这样得到一张新图。

如果原图从$S$到任一点的路径上没有零环、负环，则显然这张图是一个DAG（有向无环图）。

我们对这张图求出一个以$S$为根的外向生成树，称为最短路径树。
这个生成树一定能求出来的，因为新图上只有$S$点可能入度为$0$，我们可以通过归纳来得到这个结论。（具体来说，我们考虑往图上添加一个入度不为0的点，或添加一个有向边，结论仍然成立）

那么根据引理3和归纳法，我们可以知道，如果从$S$到任意点没有负环，对最短路径树进行宽度优先遍历，在遍历到节点$u$的同时，用它与它父亲连接的那条边对$u$在原图上进行松弛操作，会得到$d_u=di{s}_{S,u}$。

贝尔曼-福特算法

对图中的每一条边都进行一遍松弛的过程（松弛顺序无所谓），我们称为进行了一次全局松弛。

贝尔曼福特算法证明：从$S$开始到任意可达点的无负环的充要条件是，对图进行$n?1$轮全局松弛后$d_u=di{s}_{S,u}$。

贝尔曼福特算法同时也给出了$S$到任意可达点有至少一条路径经过负环的充要条件，即再进行第$n$轮全局松弛时，有至少一个点仍被松弛。

证明：
我们假设从$S$到$u$的经过的点数最少的最短路径的点数为$k+1$，我们可以归纳证明，点$u$最后一次被松弛是在第$k$轮全局松弛时，并此时$di{s}_{S,u}=d_u$。因此证完。

显然贝尔曼福特算法的复杂度为$O(nm)$

贝尔曼-福特算法的实现：

• 先重复进行$n?1$轮全局松弛
• 再进行一轮全局松弛，期间观察是否有点会被再次松弛，如果有，那么报告有负环。

贝尔曼-福特算法理论上码量比SPFA要小，但是我个人感觉SPFA好写，由于二者最劣复杂度一样，因此我们学习SPFA。

最短路径快速算法（SPFA）

最短路径快速算法的英文是“Shortest Path Faster Algorithm”，从这可以看出它在随机图下表现相当优秀，经过分析可以知道它在随机图下表现的复杂度大概为$O(m+n{\log }^{2}n)$，但是它的最劣复杂度仍为$O(nm)$。

SPFA算法是贝尔曼福特算法的队列优化版本，其核心思想在于，只有前驱在第$k?1$轮全局松弛中被松弛的节点，才有可能在第$k$轮松弛中被松弛，因此我们可以用队列来模拟这个过程，具体来说是：

• 初始把$S$入队
• 取出队头$u$
• 如果$u$已经入队$n$次，那么报告有负环。
• 用队头$u$去松弛它的所有后继，并把所有松弛成功的不在队列内的后继入队。
• 弹出队头
• 重复这个过程直到队列为空

注意有负环一定是入队$n$次，而不是松弛$n$次。因为入队$n$次表示目前进行的是第$n$轮全局松弛，但是松弛$n$次并不一定。

正确性证明：
如果把所有松弛成功的点直接入队，那么这个算法的正确性是显然的。
现在考虑为什么如果一个点$v$在队列内，那么就不需要重复入队：
假设$v$被$u$松弛成功，此时实际上是第$k$轮全局松弛，即将入队之时发现它已经在队列内，此时有两种可能性：

• $v$是在第$k$轮全局松弛时入队的：
  因此$v$在队列表示，第$k+1$轮全局松弛需要用$v$来松弛，因此显然$v$不需要再入队一次。
• $v$是在第$k?1$轮全局松弛时入队的：
  我们考虑按照队序顺次执行第$k$轮松弛，把最后一个成功松弛$v$的点设为$x$。
  • 如果$x$队序在$v$之后：
    那么说明$v$已经再次入队，并表示第$k+1$轮松弛需要用到$v$来更新，此时显然正确。
  • 否则$x$队序在$v$之前：
    那么由于把$v$在第$k+1$轮入队的唯一作用就是，计算在第$k$轮中对$v$松弛造成的影响。而这个影响可以直接由$v$这个位置计算，因此是可以的。

QED.

实现

#include<iostream>
#include<vector>
#include<queue>
#include<map>
using namespace std;
const int N=1e5;
vector<pair<int,int>> a[N+5];
long long d[N+5];
bool vis[N+5];
int cnt[N+5];
int n,m,s;
void Dijk(int s) {
	for(auto&i:d) i=1e18;
	d[s]=0;
	queue<int>q;
	q.push(s);
	while(!q.empty()) {
		int u=q.front();
		q.pop();
		vis[u]=false;
		if(++cnt[u]>=n) throw;有负环
		for(auto&i:a[u]) {
			int v=i.second;
			long long w=i.first;
			if(d[v]>d[u]+w) {
				d[v]=d[u]+w;
				if(!vis[v])
					q.push(v);
			}
		}
	}
}
int main() {
	cin>>n>>m>>s;
	for(int i=1,u,v,w; i<=m; i++) {
		cin>>u>>v>>w;
		a[u].push_back({w,v});
	}
	Dijk(s);
	for(int i=1; i<=n; i++) cout<<min(d[i],(1ll<<31)-1)<<' ';
}

SPFA算法有很多的优化，例如dfs-SPFA就是用栈来模拟SPFA的过程，这种做法在判断负环上似乎有着不错的表现，但是最劣情况下仍然是指数级别的。除此以外，堆优化SPFA/SLF/LLL的优化在负权图上都有可能被卡成指数级算法。

弗洛伊德算法（Floyd）

弗洛伊德算法能够以$O(n^3)$的复杂度求出有向有权图中任意两点之间的最短路径长度，并以$O(n^3)$的复杂度判断负环，看起来用处不大，但是有的时候还是有用的。

弗洛伊德算法实质上是一种动态规划算法。

首先设$f_{k,i,j}$表示起点为$i$，终点为$j$的所有路径中，不包括起点和终点，经过的点编号均在$[1,k]$之间的最短路。

初值：

• $f_{k,i,i}=0$
• 如果$i$到$j$有边，$f_{0,i,j}=w_{i,j}$，如果有重边，选择边权最小的一条边。
• 其余$f_{k,i,j}=+\infty$

转移：
f k , i , j = min ? { f k ? 1 , i , j , f k ? 1 , i , k + f k ? 1 , k , j } f_{k,i,j}=\min\{f_{k-1,i,j},f_{k-1,i,k}+f_{k-1,k,j}\} fk,i,j?=min{fk?1,i,j?,fk?1,i,k?+fk?1,k,j?}

注意到$f_{k?1,i,k}=f_{k,i,k},f_{k?1,k,j}=f_{k,k,j}$，并且有一个转移是从$f_{k?1,i,j}\to f_{k,i,j}$，因此可把贡献写成这个形式：
$k\in [1,n]:f_{i,j}\min \leftarrow f_{i,k}+f_{k,j}$

时间复杂度$O(n^3)$

因为dp结束后，$f_{i,j}$的意义是，从$i$到$j$经过的边数不超过$n$的最短路径，所以图上存在负环的充要条件是，dp结束后存在$f_{i,i}<0$。

注意，必须要先枚举$k$，如果不先枚举$k$是一定会错的。

负环

我们讨论几个问题：

• 负环判断问题
• 无穷最短路径问题
• 负环构造问题
• 负环计数问题

负环判断问题

以$S$为起点进行SPFA，容易判断是否存在$S$可达的负环。很多情况下我们更想知道这张图中是否存在负环，这时候我们需要建立虚拟源点，让源点向着每个点连接一个长度为$0$的有向边，这时候在以源点为起点跑SPFA，就可以判断图中是否存在负环。

尤其需要注意，由于我们建立的虚拟源点，因此事实上图中一共有$n+1$个点，因此入队次数并不是为$n$即说明有负环，而是入队次数等于$n+1$说明有负环。

因此实际跑SPFA的过程中，我们可以多跑几层bfs，例如统一当入队次数为$n+2$时再报告负环。

无穷最短路径问题

无穷最短路径问题指的是，对于以$S$为起点，对$S$距离其有限长度的所有点求出最短路，并求出$S$到哪些点的最短路为$?\infty$。

事实上SPFA可以部分处理图中有负环的情况：

假设红色为负环，虽然负环可达的点的最短路无法求出，但是由于中止算法时已经是在模拟第$n$轮全局松弛，剩余部分的最短路在中止算法时是已经求出了的。

如果我们能够求出负环上至少一点的位置，那么我们就可以通过缩点在DAG上dp的方法来得知，哪些点是负环可达的点。

负环位置定理

事实上有以下事实：
负环所在的强连通分量的点没有有限长度的最短路。
负环可达的强连通分量的点没有有限长度的最短路。
这都是显然的。

为了方便，我们称有负环存在的连通分量为负连通分量，那么我们就会知道：
不存在两个强负连通分量互相可达。

这也是显然的，因为不存在两个强连通分量互相可达。

如果一个强负连通分量不可以被其他任何强负连通分量达到，那么称这个强负连通分量为关键强负连通分量。具体来说就是“处于可达关系最上层的强负连通分量”，关键强负连通分量意味着它可达的所有点都无法求出有限长度的最短路：

用红色表示负环，这张图中有两个关键强负连通分量，用绿色圈起来了。

负环位置定理：
每个关键强负连通分量上至少有一点在SPFA算法中入队$n$次（或在贝尔曼福特算法的第$n$轮全局松弛中仍被松弛成功。）

换句话说：
强连通分量$X$是关键强负连通分量，是$X$上至少有一点在SPFA算法中入队$n$次的充分条件。（注意不是必要条件，因为入队$n$次的点也可能是负环可达的点。）

这个定理显然成立。

如果要找到每个$S$可达的关键强负连通分量，那么我们就不能在发现有点入队次数为$n$时立即break，而是将入队次数为$n$的点标记下来，然后等到发现有点入队次数为$n+1$时，在break。

时间复杂度$O(nm)$

负环构造问题

在一张图中，可能存在的负环数量是指数级的，因此想要找到一个复杂度非指数级的构造所有负环的算法是不可能的。
但是我们可以找到图中的某个负环。

非简单负环一定是由负环+负环/正环/零环构成，因此存在非简单负环的充要条件是存在简单负环，因此我们只需要找简单负环。

假如说$v$最后一次是被点$u$松弛，那么我们认为当前最短路径树上$u$是$v$的父亲，我们可以通过使用LCT维护当前最短路径树之类的办法来求出图中的一个简单负环。
因为求出一个负环之后最短路径树就不复存在了，因此不太能做。

如果我们想要求出图中多个负环，那么注意到简单负环一定是最小环，我们可以模仿求最小环的方法求出负环。

例如使用弗洛伊德算法以$O(n^3)$的时间复杂度求出图中的若干个简单负环。

除此之外还有一些复杂度高达$O(n{m}^2)$之类的奇怪办法求负环，大概的思想是：

• 枚举一条边$(u,v)$，假设它在负环上
• 在去除这条边的图上跑SPFA求出$v$到$u$的最短路
• 如果发现$v$到$u$有负环，那么说明在没有这条边的情况下图仍有负环，永久删去这条边，在新图上递归找负环
• 否则我们就找到了包含这条边的最小环，检验一下是否为负环，如果为负环那就找到了

但是这个东西的期望时间复杂度为$O(nm{\log }^{2}n)$

有没有其他做法呢？

• 如果找到有限个负环，并且实际上负环足够多的话，可以直接维护最短路径树来做。
• 如果负环不够多呢？
• 说明负环应该不太多，可以试试直接搜
• 不知道

负环计数问题

负环计数问题明显是强于环计数问题的，环计数问题没有公认的多项式做法，所以负环计数问题也没有。

约翰逊算法

约翰逊算法以$O(nm+km\log m)$的复杂度求出有权有向图中$k$个起点的单源最短路径，它的时间复杂度事实上是一遍SPFA加$k$遍迪杰斯特拉。

为了方便我们假设图中没有负环，如果图中有负环，那么关键强负连通分量可达的点可以直接删去。这是一个无穷最短路径问题。

约翰逊算法的关键在于重定边权，使得图中没有负权边，因此可以跑迪杰斯特拉算法。

假设我们以$S$为超级源点求出单源最短路径$d$，那么对于每条边都会有$(u,v)$：
$d_u+w\ge d_v$

也即：$d_u?d_v+w\ge 0$
所以我们令这条边的新边权为$w^{\prime }=d_u?d_v+w$

容易发现这样得到的新图上从$S$到$T$的路径的长度实际为：$d_S?d_u+原图上对应路径的长度$

并且这条边的边权始终非负，因此可以对每个起点都跑迪杰斯特拉。

迪杰斯特拉算法求单源k短路径

显然在堆优化迪杰斯特拉算法节点$u$第$k$次出队时，对应的是从$S$到$u$的第$k$短路径（非严格），因此我们可以使用堆优化迪杰斯特拉算法来求出第$k$短路，其时间复杂度为$mk\log mk$。

其只能应用于有向非负权图。想要将其应用于有向有权图上，一种简单的方法是，使用约翰逊方法重定边权。

如果我们要求出严格次短路，那我们就要找到第一次，出队时对应的距离严格大于最短路径，的时间。

启发式搜索算法（A*）

启发式搜索算法通常由于快速求出从源点$S$到汇点$T$的第$k$短路，其关键在于，把迪杰斯特拉算法中小顶堆比较的权值由$d_u$改为$d_u+di{s}_{u,T}$，也就是加入估价函数值的优先队列bfs。

由于A*算法的正确性分析，这个算法是一定对的。
该算法平常表现不错，但是其最劣复杂度仍为$O(mk\log m)$，也就是会被卡。

有向无环图的单源最短路径

有向无环图的单源最短路径可以DAG上dp得到。

具体来说，设$f_u$表示$S$到$u$的最短路径，则 f v = min ? u → v { f u + w } f_v=\underset{u\rightarrow v}\min\{f_u+w\} fv?=u→vmin?{fu?+w}

初始$f_S=0,f_{u\ne S}=+\infty$

时间复杂度$O(n+m)$

可以求出拓扑序之后dp，或者进行记忆化搜索。

后记

于是皆大欢喜。