第k短路（Dijkstra & A*）
最短路，即第1短路有很多种求法，SPFA，Dijkstra等，但第k短路怎么求呢？其实也是基于Dijkstra；因为Dijkstra用的是堆优化，这样保证每次弹出来的都是最小值，只是求最短路只是弹出一次就返回了，我们可以用Dijkstra弹出k个距离后再返回，这样根据弹出的先后顺序能够求出1~k短路
#include <bits/stdc++.h> using namespace std; typedef long long ll; const int INF = 0x3f3f3f3f; const int MAXN = 5e5 + 100; const int MAXM = 3e3 + 10; inline int read() { int x = 0, ff = 1; char ch = getchar(); while(!isdigit(ch)) { if(ch == '-') ff = -1; ch = getchar(); } while(isdigit(ch)) { x = (x << 1) + (x << 3) + (ch ^ 48); ch = getchar(); } return x * ff; } inline void write(ll x) { if(x < 0) putchar('-'), x = -x; if(x > 9) write(x / 10); putchar(x % 10 + '0'); } int n, m, k, v; ll ans, dist[110]; int lin[MAXN], tot = 0; struct edge { int y, v, next; }e[MAXN]; inline void add(int xx, int yy, int vv) { e[++tot].y = yy; e[tot].v = vv; e[tot].next = lin[xx]; lin[xx] = tot; } void Dijkstra() { priority_queue < pair < int , int > > q; q.push(make_pair(0, 1)); while(!q.empty()) { int x = q.top().second; int d = -q.top().first; q.pop(); if(x == n) { dist[++v] = d; if(v == k + 1) return ; } for(int i = lin[x], y; i; i = e[i].next) { y = e[i].y; ans = d + e[i].v; q.push(make_pair(-ans, y)); } } } int main() { memset(dist, -1, sizeof(dist)); n = read(); m = read(); k = read(); for(int i = 1; i <= m; ++i) { int x,y,v; x = read(); y = read(); v = read(); add(x, y, v); } Dijkstra(); for(int i = 1; i <= k; ++i) { write(dist[i]); putchar('\n'); } return 0; }
emmmmm, 还有一种更高级的算法， 先来回顾优先队列的BFS， 不断从堆中取出“当前代价最小” 的状态进行拓展。每个状态第一次从堆中取出时， 就得到了从初态到该状态的最小代价。然而， 一个状态当前最小， 不代表从该状态到目标状态代价就最小，但是优先队列BFS会先选择这个分支， 导致搜索量增大；
所以， 我们能够想到， 设计一个函数， 计算从该状态到目标状态的代价的估计值， 仍然维护一个堆，把当前价值 + 估计价值最小作为拓展；估价函数原则是估价值 <- 实际值（不再证明。。。）
在求第k短路时， 我们把最短路作为估价， 保证估价 <= 实际， 还能顺应实际的变化趋势
#include <bits/stdc++.h> using namespace std; typedef long long ll; const int INF = 0x3f3f3f3f; const int MAXN = 5e5 + 100; const int MAXM = 3e3 + 10; template < typename T > inline void read(T &x) { x = 0; T ff = 1, ch = getchar(); while(!isdigit(ch)) { if(ch == '-') ff = -1; ch = getchar(); } while(isdigit(ch)) { x = (x << 1) + (x << 3) + (ch ^ 48); ch = getchar(); } x *= ff; } template < typename T > inline void write(T x) { if(x < 0) putchar('-'), x = -x; if(x > 9) write(x / 10); putchar(x % 10 + '0'); } int n, m, s, t, k; int f[MAXN], vis[MAXN]; int lin[MAXN], tot = 0, linc[MAXN], totc = 0; struct edge { int y, v, next; }a[MAXN], e[MAXN]; struct node { int pos, f, dis; bool operator < (node a) const { return a.f + a.dis < f + dis; } }; inline void add(int xx, int yy, int vv) { a[++tot].y = yy; a[tot].v = vv; a[tot].next = lin[xx]; lin[xx] = tot; } inline void addc(int xx, int yy, int vv) { e[++totc].y = yy; e[totc].v = vv; e[totc].next = linc[xx]; linc[xx] = totc; } void SPFA() { queue < int > q; memset(f, 0x3f, sizeof(f)); memset(vis, false, sizeof(vis)); q.push(t); f[t] = 0; vis[t] = true; while(!q.empty()) { int x = q.front(); q.pop(); vis[x] = false; for(int i = lin[x], y; i; i = a[i].next) { if(f[y = a[i].y] > f[x] + a[i].v) { f[y] = f[x] + a[i].v; if(!vis[y]) { vis[y] = true; q.push(y); } } } } } int astar() { priority_queue < node > q; if(f[s] == INF) return -1; int ts[MAXN]; node tmp, h; h.pos = s; h.f = 0; h.dis = 0; q.push(h); while(!q.empty()) { node x = q.top(); q.pop(); ts[x.pos]++; if(ts[x.pos] == k && x.pos == t) return x.dis; if(ts[x.pos] > k) continue; for(int i = linc[x.pos]; i; i = e[i].next) { tmp.pos = e[i].y; tmp.f = f[e[i].y]; tmp.dis = x.dis + e[i].v; q.push(tmp); } } return -1; } int main() { read(n); read(m); for(int i = 1; i <= m; ++i) { int u, v, w; read(u); read(v); read(w); add(v, u, w); addc(u, v, w); } read(s); read(t); read(k); if(s == t) ++k; SPFA(); write(astar()); return 0; }
