An Old but Classic Problem
给定一个$n$个点，$m$条边的带正权有向图。给定$s$和$t$，询问$s$到$t$的所有权和为正路径中，第$k$短的长度。
Notice
定义两条路径不同，当且仅当它们的边集中存在一条边，使得它只在其中的一条路径上。
Solution#1 Shortest Path & A*
对于Dijstra算法，有一个结论就是，当一个点第$k$次出队的时候，此时路径长度就是$s$到它的第$k$短路。
那为什么还要A*呢？我试了试，写了个Dijstra，然后交了一发poj 2449，于是MLE了。。。如果您觉得我的Dijstra太丑了，您可以手写一个交一发。
所以用A*来优化优化状态数（其实就是玄学优化，需要你的人品还有出题人的素质）。
首先建反图，跑一次最短路算法，得到每个点到$t$的最短路的距离。
然后用当前走的距离加上到终点的最短路的长度作为优先级进行A*。
那如何得到答案？
- 当一个点第k次出队时，答案是它的优先级
- 当终点第k次出队时，答案是它已经走的路程
据说A*可以被卡成$O\left(nk\log n \right )$，只是我不会QAQ。
Code
1 /** 2 * poj 3 * Problem#2449 4 * Accepted 5 * Time: 250ms 6 * Memory: 9252k 7 */ 8 #include <iostream> 9 #include <fstream> 10 #include <sstream> 11 #include <algorithm> 12 #include <cstdio> 13 #include <cstdlib> 14 #include <cstring> 15 #include <ctime> 16 #include <cctype> 17 #include <cmath> 18 #include <vector> 19 #include <queue> 20 #include <stack> 21 #include <map> 22 #include <set> 23 #include <bitset> 24 using namespace std; 25 typedef bool boolean; 26 27 typedef class Edge { 28 public: 29 int end; 30 int next; 31 int w; 32 33 Edge(int end = 0, int next = -1, int w = 0):end(end), next(next), w(w) { } 34 }Edge; 35 36 const int N = 1e3, M = 1e5; 37 38 typedef class MapManager { 39 public: 40 int cnt; 41 int h[N + 5]; 42 Edge edge[M + 5]; 43 44 MapManager() { } 45 MapManager(int n):cnt(-1) { 46 // h = new int[(n + 1)]; 47 // edge = new Edge[(m + 1)]; 48 memset(h, -1, sizeof(int) * (n + 1)); 49 } 50 51 inline void addEdge(int u, int v, int w) { 52 edge[++cnt] = (Edge(v, h[u], w)); 53 // h[u] = (signed)edge.size() - 1; 54 h[u] = cnt; 55 } 56 57 inline int start(int node) { return h[node]; } 58 59 Edge& operator [] (int pos) { 60 return edge[pos]; 61 } 62 }MapManager; 63 #define m_endpos -1 64 65 int n, m; 66 MapManager g; 67 MapManager rg; 68 int s, t, k; 69 int ds[N + 5]; 70 71 inline void init() { 72 scanf("%d%d", &n, &m); 73 memset(g.h, -1, sizeof(int) * (n + 1)); 74 memset(rg.h, -1, sizeof(int) * (n + 1)); 75 for(int i = 1, u, v, w; i <= m; i++) { 76 scanf("%d%d%d", &u, &v, &w); 77 g.addEdge(u, v, w); 78 rg.addEdge(v, u, w); 79 } 80 scanf("%d%d%d", &s, &t, &k); 81 // ds = new int[(n + 1)]; 82 } 83 84 #define g rg 85 #define f ds 86 #define que que1 87 boolean vis[N + 5]; 88 queue<int> que; 89 boolean spfa(int s, int t) { 90 memset(f, 0x7f, sizeof(int) * (n + 1)); 91 memset(vis, false, sizeof(boolean) * (n + 1)); 92 que.push(s); 93 f[s] = 0; 94 while(!que.empty()) { 95 int e = que.front(); 96 que.pop(); 97 vis[e] = false; 98 for(int i = g.start(e); i != m_endpos; i = g[i].next) { 99 int& eu = g[i].end; 100 // cout << e << " " << eu << " " << i <<endl; 101 if(f[e] + g[i].w < f[eu]) { 102 f[eu] = f[e] + g[i].w; 103 if(!vis[eu]) { 104 que.push(eu); 105 vis[eu] = true; 106 } 107 } 108 } 109 } 110 return (f[t] != 0x7f7f7f7f); 111 } 112 #undef g 113 #undef f 114 #undef que 115 116 typedef class Status { 117 public: 118 int node; 119 int dis; 120 int priority; 121 122 Status(int node = 0, int dis = 0):node(node), dis(dis), priority(h()) { } 123 124 int h() { 125 return dis + ds[node]; 126 } 127 128 boolean operator < (Status b) const { 129 return priority > b.priority; 130 } 131 }Status; 132 133 int label[N + 5]; 134 priority_queue<Status> que; 135 int bfs(int s, int t) { 136 if(s == t) k++; 137 // label = new int[(n + 1)]; 138 memset(label, 0, sizeof(int) * (n + 1)); 139 que.push(Status(s, 0)); 140 while(!que.empty()) { 141 Status e = que.top(); 142 que.pop(); 143 label[e.node]++; 144 if(e.node == t && label[e.node] == k) 145 return e.dis; 146 for(int i = g.start(e.node); i != m_endpos; i = g[i].next) { 147 if(label[g[i].end] < k) 148 que.push(Status(g[i].end, e.dis + g[i].w)); 149 } 150 } 151 return -1; 152 } 153 154 inline void solve() { 155 if(!spfa(t, s)) { 156 puts("-1"); 157 return; 158 } 159 printf("%d", bfs(s, t)); 160 } 161 162 int main() { 163 init(); 164 solve(); 165 return 0; 166 }
Solution#2 Shortest Path & Protractable Heap
考虑建立反图，然后跑最短路算法得到以$t$为根的最短路径生成树。
当走了一条非树边$(u, v, w)$意味着什么？
最终的路径长度就会因此增加$f[v] - f[u] + w$。
对于一条路径，我们依次将它经过的非树边记下来，约定得到的序列是这条路径的非树边序列。
考虑对于一个合法的非树边序列，我们可以找到唯一的一条$s$到$t$的路径与之对应。
因此，$k$短路的长度就等于第$k$小的代价和加上$s$到$t$的最短路的长度。
考虑如何来得到一个合法的非树边序列。
- 找到一条起点在当前点$p$到根$t$的路径上的非树边
- 令p等于这条边的终点。
我们可以通过这样的方法来得到所有的非树边序列。但是我们并不需要所有的非树边序列，因此当找到第$x$短路后再进行拓展状态，然后用优先队列来维护。
但是这样每次拓展时间复杂度可达$O(m)$，总时间复杂度可以达到$O\left(mk\log \left (mk \right ) \right )$。
令人无法接受。但是其中真正会被用到的状态十分少。
因此可以像UVa 11997那样进行优化。
当一个非树边序列出队时，代价和比它大的才可能有用。
因此，考虑一个非树边序列出队时通过下面的方法来进行得到新的序列:
- 追加操作：假如最后一条非树边的终点为$v$，找到一条起点在$v$到$t$的路径上代价最小的非树边追加在当前非树边序列后
- 替换操作：将最后一条非树边更换为代价比它大的1条非树边。
例如图中橙色虚线是被替换掉的非树边，紫色是新加入的非树边
考虑用一些可持久化数据结构（如可持久化斜堆，可持久化线段树，可持久化Treap）来维护起点在点$u$到根的路径上的非树边的代价。
对于替换操作，
- 如果用的可持久化堆，那么把最后一条非树边替换为它所在的堆（你从哪个堆把它拿出来的）中它的左右子节点代表的边。
- 如果用的可持久化平衡树，那么把最后一条非树边直接替换为它的后继
- ......
这是一个很稳定的算法，时间复杂度$O\left ( n + m\log m + k\log k \right )$。就是常数有点大，sad.....
注意一些细节
- 计算代价时需要考虑终点是否可以到达$t$
- 考虑$s = t$时，要求的$k$短路包不包含0
- $k$短路不存在，队首为空
Code
1 /** 2 * poj 3 * Problem#2449 4 * Accepted 5 * Time: 438ms 6 * Memory: 15196k 7 */ 8 #include <algorithm> 9 #include <iostream> 10 #include <cstring> 11 #include <cstdio> 12 #include <vector> 13 #include <queue> 14 using namespace std; 15 typedef bool boolean; 16 17 #define pii pair<int, int> 18 #define fi first 19 #define sc second 20 21 typedef class Node { 22 public: 23 int val, ed; 24 Node *l, *r; 25 26 Node() { } 27 Node(int val, int ed, Node *l, Node *r):val(val), ed(ed), l(l), r(r) { } 28 }Node; 29 30 #define Limit 1000000 31 32 Node pool[Limit]; 33 Node* top = pool; 34 35 Node* newnode(int val, int ed) { 36 if(top >= pool + Limit) 37 return new Node(val, ed, NULL, NULL); 38 top->val = val, top->ed = ed, top->l = top->r = NULL; 39 return top++; 40 } 41 42 Node* merge(Node* a, Node* b) { 43 if (!a) return b; 44 if (!b) return a; 45 if (a->val > b->val) swap(a, b); 46 Node* p = newnode(a->val, a->ed); 47 p->l = a->l, p->r = a->r; 48 p->r = merge(p->r, b); 49 swap(p->l, p->r); 50 return p; 51 } 52 53 typedef class Status { 54 public: 55 int dist; 56 Node* p; 57 58 Status(int dist = 0, Node* p = NULL):dist(dist), p(p) { } 59 60 boolean operator < (Status b) const { 61 return dist > b.dist; 62 } 63 }Status; 64 65 typedef class Edge { 66 public: 67 int end, next, w; 68 69 Edge(int end = 0, int next = 0, int w = 0):end(end), next(next), w(w) { } 70 }Edge; 71 72 typedef class MapManager { 73 public: 74 int ce; 75 int* h; 76 Edge* es; 77 78 MapManager() { } 79 MapManager(int n, int m):ce(0) { 80 h = new int[(n + 1)]; 81 es = new Edge[(m + 5)]; 82 memset(h, 0, sizeof(int) * (n + 1)); 83 } 84 85 void addEdge(int u, int v, int w) { 86 es[++ce] = Edge(v, h[u], w); 87 h[u] = ce; 88 } 89 90 Edge& operator [] (int pos) { 91 return es[pos]; 92 } 93 }MapManager; 94 95 int n, m; 96 int s, t, k; 97 MapManager g; 98 MapManager rg; 99 boolean *vis; 100 int* f, *lase; 101 102 inline void init() { 103 scanf("%d%d", &n, &m); 104 g = MapManager(n, m); 105 rg = MapManager(n, m); 106 for (int i = 1, u, v, w; i <= m; i++) { 107 scanf("%d%d%d", &u, &v, &w); 108 g.addEdge(u, v, w); 109 rg.addEdge(v, u, w); 110 } 111 scanf("%d%d%d", &s, &t, &k); 112 } 113 114 queue<int> que; 115 void spfa(MapManager& g, int s) { 116 vis = new boolean[(n + 1)]; 117 f = new int[(n + 1)]; 118 lase = new int[(n + 1)]; 119 memset(f, 0x7f, sizeof(int) * (n + 1)); 120 memset(vis, false, sizeof(boolean) * (n + 1)); 121 que.push(s); 122 f[s] = 0, lase[s] = 0; 123 while (!que.empty()) { 124 int e = que.front(); 125 que.pop(); 126 vis[e] = false; 127 for (int i = g.h[e]; i; i = g[i].next) { 128 int eu = g[i].end, w = g[i].w; 129 if (f[e] + w < f[eu]) { 130 f[eu] = f[e] + w, lase[eu] = i; 131 if (!vis[eu]) { 132 vis[eu] = true; 133 que.push(eu); 134 } 135 } 136 } 137 } 138 } 139 140 Node** hs; 141 inline void rebuild() { 142 for (int i = 1; i <= n; i++) 143 for (int j = g.h[i]; j; j = g[j].next) { 144 int e = g[j].end; 145 if (lase[i] != j) 146 g[j].w += f[e] - f[i]; 147 } 148 149 hs = new Node*[(n + 1)]; 150 que.push(t); 151 hs[t] = NULL; 152 while (!que.empty()) { 153 int e = que.front(); 154 que.pop(); 155 if (lase[e]) 156 hs[e] = hs[g[lase[e]].end]; 157 for (int i = g.h[e]; i; i = g[i].next) 158 if (lase[e] != i && f[g[i].end] != 0x7f7f7f7f) 159 hs[e] = merge(hs[e], new Node(g[i].w, g[i].end, NULL, NULL)); 160 for (int i = rg.h[e]; i; i = rg[i].next) { 161 int eu = rg[i].end; 162 if (lase[eu] == i) 163 que.push(eu); 164 } 165 } 166 } 167 168 inline int kthpath(int k) { 169 if (s == t) 170 k++; 171 if (f[s] == 0x7f7f7f7f) 172 return -1; 173 if (k == 1) 174 return f[s]; 175 176 priority_queue<Status> q; 177 if (!hs[s]) 178 return -1; 179 180 q.push(Status(hs[s]->val, hs[s])); 181 while (--k && !q.empty()) { 182 Status e = q.top(); 183 q.pop(); 184 185 if(k == 1) 186 return e.dist + f[s]; 187 188 int eu = e.p->ed; 189 if (hs[eu]) 190 q.push(Status(e.dist + hs[eu]->val, hs[eu])); 191 if (e.p->l) 192 q.push(Status(e.dist - e.p->val + e.p->l->val, e.p->l)); 193 if (e.p->r) 194 q.push(Status(e.dist - e.p->val + e.p->r->val, e.p->r)); 195 } 196 return -1; 197 } 198 199 inline void solve() { 200 printf("%d\n", kthpath(k)); 201 } 202 203 int main() { 204 init(); 205 spfa(rg, t); 206 rebuild(); 207 solve(); 208 return 0; 209 }
特别鸣谢
YJQ
ZJC
