Problem
acm.hdu.edu.cn/showproblem.php?pid=6181
Reference
Dijkstra应用之次短路
2017 Multi-University Training Contest 10 1011 Two Paths HDU 6181 (次短路)
刷题—— hdu 6181 Two Paths
HDU6181-Two Paths【A*算法】
Meaning
给一幅 n 个点的无重边、无自环的无向图,求从 1 到 n 的次短路。
Analysis
求次短路,就另开一个数组存次短路的值,在求最短路时顺便更新次短路,有几种情况:
- A 的最短路更新 B 的最短路,那 B 原来的最短路变成新的次短路;
- A 的最短路不能更新 B 的最短路,但能更新 B 次短路,则更新它;
- A 的次短路更新 B 的次短路;
借这题记录几种求次短路的写法。
Code
Dijkstra
- 要注意优先队列的第三个参数,之前写成
priority_queue<P>
超时了,改成priority<P, vector<P>, greater<P> >
才过的。它默认是less<P>
?总之要注意小于号和这个greater / less
共同产生的神奇效果
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <utility>
using namespace std;
const int N = 100000, M = N;
int head[N+1], to[M<<1], w[M<<1], nxt[M<<1];
void add_edge(int f, int t, int l, int sz)
{
to[sz] = t;
w[sz] = l;
nxt[sz] = head[f];
head[f] = sz;
}
long long one[N+1], two[N+1]; // 最短、次短
typedef pair<long long,int> P; // 距离、点的编号
priority_queue<P, vector<P>, greater<P> > que; // greater<P> !
void Dijkstra()
{
memset(one, 7, sizeof one);
memset(two, 7, sizeof two);
one[1] = 0;
que.push(P(0LL, 1));
for(P tp; !que.empty(); que.pop())
{
tp = que.top();
if(tp.first > two[tp.second])
continue;
long long d = tp.first;
int v = tp.second;
for(int i = head[v]; ~i; i = nxt[i])
{
tp.first = d + w[i];
// 更新最短路
if(one[to[i]] > tp.first)
{
tp.second = to[i];
que.push(tp);
// 把原来的最短路长度换出来
// 在下面用来更新次短路
swap(one[to[i]], tp.first);
}
// 更新次短路
if(one[to[i]] < tp.first && tp.first < two[to[i]])
{
two[to[i]] = tp.first;
tp.second = to[i];
que.push(tp);
}
}
}
}
int main()
{
int T;
scanf("%d", &T);
while(T--)
{
int n, m;
scanf("%d%d", &n, &m);
memset(head, 0xff, sizeof head);
for(int i = 0, f, t, l, sz = 0; i < m; ++i)
{
scanf("%d%d%d", &f, &t, &l);
add_edge(f, t, l, sz++);
add_edge(t, f, l, sz++);
}
Dijkstra();
printf("%I64d\n", two[n]);
}
return 0;
}
SPFA
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
const int N = 100000, M = N;
int head[N+1], to[M<<1], w[M<<1], nxt[M<<1];
void add_edge(int f, int t, int l, int sz)
{
to[sz] = t;
w[sz] = l;
nxt[sz] = head[f];
head[f] = sz;
}
long long one[N+1], two[N+1]; // 最短、次短
bool inq[N+1];
queue<int> que;
void SPFA()
{
memset(one, 7, sizeof one);
memset(two, 7, sizeof two);
one[1] = 0;
memset(inq, false, sizeof inq);
que.push(1);
inq[1] = true;
for(int tp; !que.empty(); que.pop())
{
tp = que.front();
bool psh = inq[tp] = false;
for(int i = head[tp]; ~i; i = nxt[i])
{
long long d = one[tp] + w[i];
// 能更新最短路
if(one[to[i]] > d)
{
two[to[i]] = one[to[i]];
one[to[i]] = d;
psh = true;
}
// 不能更新最短路
// 但能更新次短路
else if(one[to[i]] < d && d < two[to[i]])
{
two[to[i]] = d;
psh = true;
}
// 用次短路更新次短路
// 不能少写这种情况
if(two[to[i]] > two[tp] + w[i])
{
two[to[i]] = two[tp] + w[i];
psh = true;
}
if(psh && !inq[to[i]])
{
inq[to[i]] = true;
que.push(to[i]);
}
}
}
}
int main()
{
int T;
scanf("%d", &T);
while(T--)
{
int n, m;
scanf("%d%d", &n, &m);
memset(head, -1, sizeof head);
for(int i = 0, f, t, l, sz = 0; i < m; ++i)
{
scanf("%d%d%d", &f, &t, &l);
add_edge(f, t, l, sz++);
add_edge(t, f, l, sz++);
}
SPFA();
printf("%I64d\n", two[n]);
}
return 0;
}
A*
- A* 可以用来求 k 短路,相当于第 k 次走到终点。
- A* 首先从终点反向求一次所有点离终点的最短距离,作为估价函数。如果记
s(i):起点到 i 的最短距离
、d(i):点 i 到终点的最短距离
,那么f(i) = s(i) + d(i)
就是从点 i 走到终点的总距离。 - 然后,从起点出发,把它周围的点都丢进一个堆(优先队列)里,每次都优先取出
f(i)
值最小的点,又对取出的点重复上面的操作。如果取出来的点是终点,就是到达终点。第 k 次取出终点就是走 k 短路到达终点。
#include <cstdio>
#include <cstring>
#include <queue>
#include <utility>
using namespace std;
const int N = 100000, M = N;
int head[N+1], to[M<<1], w[M<<1], nxt[M<<1];
void add_edge(int f, int t, int l, int sz)
{
to[sz] = t;
w[sz] = l;
nxt[sz] = head[f];
head[f] = sz;
}
long long h[N+1]; // 估价函数的值,即 i 到终点的最短路
typedef pair<long long,int> P;
priority_queue<P, vector<P>, greater<P> > que; // greater<P> !
void Dijkstra(int n)
{
memset(h, 7, sizeof h);
h[n] = 0;
que.push(P(0LL, n));
for(P tp; !que.empty(); que.pop())
{
tp = que.top();
if(h[tp.second] < tp.first)
continue;
for(int i = head[tp.second]; ~i; i = nxt[i])
if(h[to[i]] > tp.first + w[i])
{
h[to[i]] = tp.first + w[i];
que.push(P(h[to[i]], to[i]));
}
}
}
long long A_star(int n, int k)
{
// 反向求最短路
// 当估价函数
Dijkstra(n);
que.push(P(h[1], 1));
long long res = -1;
for(P tp; !que.empty(); /* que.pop() */)
{
tp = que.top();
que.pop(); // 这句不能写在 for 的步长那里
if(tp.second == n)
{
if(k > 1) // 未足 k 次
--k;
else // 第 k 次取出
{
res = tp.first;
break;
}
}
// 先把当前结点的估价减掉
// 得到起点到当前结点的最短路
// 在周围的结点进堆时,再加回那个结点自己的估价
tp.first -= h[tp.second];
for(int i = head[tp.second]; ~i; i = nxt[i])
que.push(P(tp.first + w[i] + h[to[i]], to[i]));
}
while(!que.empty())
que.pop();
return res;
}
int main()
{
int T;
scanf("%d", &T);
while(T--)
{
int n, m;
scanf("%d%d", &n, &m);
memset(head, -1, sizeof head);
for(int i = 0, f, t, l, sz = 0; i < m; ++i)
{
scanf("%d%d%d", &f, &t, &l);
add_edge(f, t, l, sz++);
add_edge(t, f, l, sz++);
}
printf("%I64d\n", A_star(n, 2));
}
return 0;
}