次短路和第 k 短路

次短路和第 k 短路

次短路

在最短路的基础上，次短路可以由次短路$+$边更新，也可以由最短路$+$边更新，这里注意一点，因为次短路更新时也会对其它次短路产生影响，所以更新次短路时也需要入队，我们先尝试更新最短路，成功的话就把原来的最短路给次短路，不成功的话就单独尝试更新次短路。

也就是说，我们可以在算法$dijkstra$的基础上，不断维护最短路和次短路。证明则十分简单，在下面的$k$短路算法证明时，可以带入次短路，具体实现见代码。

priority_queue<pair<int, int>, vector<vector<int, int> >, greater<pair<int ,int> > > q;
memset(dis, 0x3f, sizeof dis); 
dis[1][1] = 0;//dis[i][1]表示 1 到 i 的最短路，dis[i][2]表示 1 到 i 的次短路
q.push({0, 1});
while(!q.empty())
{
    int x = q.top().second;
    int dist = q.top().first;
    q.pop();
    if(dist > dis[x][2]) continue;
    for(auto it : v[x])
    {
        int cnt = it.first;
        if(dis[cnt][1] > dist + it.second)//如果最短路需要松弛，那么当前的最短路将会被松弛，次短路就会松弛为原先的最短路
        {
            dis[cnt][2] = dis[cnt][1];
            dis[cnt][1] = dist + it.second;
            q.push({dis[cnt][1], cnt});
        }
        if(dis[cnt][2] > dist + it.second && dist + it.second > dis[cnt][1])//如果当前的路径比次短路优，而比最短路劣，那么只需要更新次短路
        {
            dis[cnt][2] = dist + it.second;
            q.push({dis[cnt][2], cnt});
        }
    }
}
return dis[n][2];//返回

那么，关于次短路，应该就结束了。

k 短路

此时，如果按照次短路的做法显然是不可行的，这时候我们需要引入一个叫做启发式搜索的东西。

A* 算法

定义

A* 搜索算法（英文：A* search algorithm，A* 读作 A-star），简称 A* 算法，是一种在图形平面上，对于有多个节点的路径求出最低通过成本的算法。它属于图遍历（英文：Graph traversal）和最佳优先搜索算法（英文：Best-first search），亦是 BFS 的改进。

过程

定义起点 $s$，终点 $t$，从起点（初始状态）开始的距离函数 $g(x) $，到终点（最终状态）的距离函数 $h(x$)$， $h^{\ast }(x)1$，以及每个点的估价函数 $f(x)=g(x)+h(x)$。

A* 算法每次从优先队列中取出一个 $f$ 最小的元素，然后更新相邻的状态。

如果 $h\le h\ast$，则 A* 算法能找到最优解。

上述条件下，如果 $h$ 满足三角形不等式，则 A* 算法不会将重复结点加入队列。

当 $h=0$ 时，A* 算法变为 $Dijkstra$；当 $h=0$ 并且边权为 $1$ 时变为 BFS。

如何用 A* 解决 k 短路问题

A* 算法定义了一个对当前状态 $x$ 的估价函数 $f(x)=g(x)+h(x)$，其中 $g(x)$ 为从初始状态到达当前状态的实际代价，$h(x)$ 为从当前状态到达目标状态的最佳路径的估计代价。每次取出 $f(x)$ 最优的状态 $x$，扩展其所有子状态，可以用 优先队列 来维护这个值。

在求解 $k$ 短路问题时，令 $h(x)$ 为从当前结点到达终点 $t$ 的最短路径长度。可以通过在反向图上对结点 $t$ 跑单源最短路预处理出对每个结点的这个值。

由于设计的距离函数和估价函数，对于每个状态需要记录两个值，为当前到达的结点 $x$ 和已经走过的距离 $g(x)$，将这种状态记为 $(x,g(x))$。

开始我们将初始状态 $(s,0)$ 加入优先队列。每次我们取出估价函数 $f(x)=g(x)+h(x)$ 最小的一个状态，枚举该状态到达的结点 $x$ 的所有出边，将对应的子状态加入优先队列。当我们访问到一个结点第 $k$ 次时，对应的状态的 $g(x)$ 就是从 $x$ 到该结点的第 $k$ 短路。

优化：由于只需要求出从初始结点到目标结点的第 $k$ 短路，所以已经取出的状态到达一个结点的次数大于 $k$ 次时，可以不扩展其子状态。因为之前 $k$ 次已经形成了 $k$ 条合法路径，当前状态不会影响到最后的答案。

当图的形态是一个 $n$ 元环的时候，该算法最坏是 $O(nk\log n)$ 的。但是这种算法可以在相同的复杂度内求出从起始点 $s$ 到每个结点的前 $k$ 短路。

具体实现

因为步骤较为繁琐，所以直接给出完整代码

#include <bits/stdc++.h>
#define IOS ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
#define x first
#define y second
using namespace std;
typedef long long ll;
typedef pair<int, pair<int, int> > PIII;
typedef pair<int, int> PII;
int s, t, k, n, m, u, v, z;
struct node
{
	int v;
	int len;
};
vector<node> mp[1010], mp_dij[1010];
int dist[1010];
bool vis[1010];
int cnt[1010];
void dij()
{
	priority_queue<PII, vector<PII>, greater<PII> > q;
	q.push({0, t});
	memset(dist, 0x3f, sizeof dist);
	dist[t] = 0;
	while(q.size())
	{
		int u = q.top().y;
		q.pop();
		if(vis[u]) continue;
		vis[u] = true;
		for(auto it : mp_dij[u])
		{
			int v = it.v;
			if(dist[v] > dist[u] + it.len) dist[v] = dist[u] + it.len, q.push({dist[v], v});
		}
	}
	return;
}
int A_star()
{
	priority_queue<PIII, vector<PIII>, greater<PIII> > q;
	q.push({dist[s], {0, s}});
	while(q.size())
	{
		PIII cur = q.top();
		q.pop();
		int u = cur.y.y;
		int dis = cur.y.x;
		cnt[u] ++;
		if(cnt[t] == k) return dis;
		if(cnt[u] > k) continue;
		for(auto it : mp[u])
		{
			int v = it.v;
			q.push({dis + it.len + dist[v], {dis + it.len, v}});
		}
	}
	return -1;
}
int main()
{
	IOS;
	cin >> n >> m;
	for(int i = 0; i < m; i ++) cin >> u >> v >> z, mp_dij[v].push_back({u, z}), mp[u].push_back({v, z});
	cin >> s >> t >> k;
	if(s == t) k ++;
	dij();
	cout << A_star();
	return 0;
}