了解A*求k短路前先从一个比较直接的思路看起
我们用一个堆来维护一系列的二元组
(
u
,
d
i
s
)
(u,dis)
(u,dis)
u表示当前节点编号,dis表示从起点s到u的某条路径长
初始时堆中只有
(
s
,
0
)
(s,0)
(s,0)
之后不断从堆顶取出dis值最小的二元组
(
u
,
d
i
s
)
(u,dis)
(u,dis)
遍历所有与u连接的结点
v
i
v_i
vi
将
(
v
i
,
d
i
s
+
d
i
s
(
u
,
v
i
)
)
(v_i,dis+dis(u,v_i))
(vi,dis+dis(u,vi))插入堆
当u第k次被从堆中取出时,就得到了从s到u的第k短路
A* 求k短路中,大体框架就是像上述这样 堆+BFS 维护
但因为估价函数的存在,时间效率大大提高
换言之,在A*算法中
每次从堆顶取出的是估价最小的结点
什么是估价函数呢
我们假设从起始状态到目标状态的总代价可以分为两部分
1.从起始状态到当前状态所需代价,记为
g
(
u
)
g(u)
g(u)
2.从当前状态到目标状态的预估代价,记为
h
(
u
)
h(u)
h(u)
那么有总代价
f
(
n
)
=
g
(
u
)
+
h
(
u
)
f(n)=g(u)+h(u)
f(n)=g(u)+h(u)
显然为了使
f
(
n
)
f(n)
f(n)最小
需要综合考虑
g
(
u
)
g(u)
g(u)与
h
(
u
)
h(u)
h(u)
因为有可能存在情况
当前代价很小,但未来将付出的代价有很大
也有可能当前代价很大,但将来要付出代价很小
前述朴素思路中就是只考虑了当前代价
g
(
u
)
g(u)
g(u)最小(当前dis最小)
即相当于预估代价总是
h
(
u
)
=
0
h(u)=0
h(u)=0
所以造成了搜索效率低
所以我们依然将从s到当前结点u距离dis作为
g
(
u
)
g(u)
g(u)
然后在A*开始前先从终点沿着反向边跑一次最短路
得到从终点到每个节点的最短距离
d
[
u
]
d[u]
d[u]作为估价函数
h
(
u
)
h(u)
h(u)
有了估价函数之后上述算法就要可以改为
用优先队列维护三元组
(
u
,
g
,
f
)
(u, g, f)
(u,g,f),含义同上述
初始时优先队列中只有
(
s
,
0
,
0
+
d
[
n
]
)
(s, 0, 0+d[n])
(s,0,0+d[n])
接着每次取出
f
f
f值最小的结点 (若存在
f
f
f先等则取
g
g
g最小) 记为
(
u
,
g
,
f
)
(u, g, f)
(u,g,f)
遍历所有与u连接的结点
v
i
v_i
vi
向优先队列中插入所有
(
v
i
,
g
+
d
i
s
(
u
,
v
i
)
,
g
+
d
i
s
(
u
,
v
i
)
+
d
[
v
i
]
)
(v_i, g+dis(u,v_i), g+dis(u,v_i)+d[v_i])
(vi,g+dis(u,vi),g+dis(u,vi)+d[vi])
当结点u第k次被取出时,就得到了s到u的第k短路
一道求次短路的模板例题
洛谷P2865 [USACO06NOV]路障Roadblocks
#include<iostream>
#include<cstdio>
#include<vector>
#include<algorithm>
#include<queue>
#include<cstring>
#include<cmath>
using namespace std;
int read()
{
int f=1,x=0;
char ss=getchar();
while(ss<'0'||ss>'9'){if(ss=='-')f=-1;ss=getchar();}
while(ss>='0'&&ss<='9'){x=x*10+ss-'0';ss=getchar();}
return x*f;
}
const int maxn=10010;
int n,m;
struct node{int v,dis,nxt;}E[maxn*20];
int head[maxn],tot;
int d[maxn],vis[maxn];
struct star
{
int v,g,f;//v结点,g当前代价 ,f总代价
bool operator < (const star &a) const
{
if(a.f==f) return a.g<g;//f为第一关键字,g为第二关键字
return a.f<f;
}
};
void add(int u,int v,int dis)
{
E[++tot].nxt=head[u];
E[tot].v=v; E[tot].dis=dis;
head[u]=tot;
}
void SPFA()
{
memset(vis,false,sizeof(vis));
memset(d,127,sizeof(d)); d[n]=0;
queue<int> q; q.push(n);
while(!q.empty())
{
int u=q.front();
q.pop(); vis[u]=0;
for(int i=head[u];i;i=E[i].nxt)
{
int v=E[i].v,dis=E[i].dis;
if(d[v]>d[u]+dis)
{
d[v]=d[u]+dis;
if(!vis[v])q.push(v),vis[v]=1;
}
}
}
}
int A_star()
{
int cnt=0;
priority_queue<star> q;
q.push( (star) {1, 0, d[1]} );//初始时堆中(s, 0, 0+d[n])
while(!q.empty())
{
star u=q.top(); q.pop();
if(u.v==n) cnt++;
if(cnt==2) return u.g;//找到第k短路
for(int i=head[u.v];i;i=E[i].nxt)
{
int v=E[i].v,dis=E[i].dis;//继续BFS扩展
q.push( (star) {v, u.g+dis, u.g+dis+d[v]} );
}
}
}
int main()
{
n=read();m=read();
for(int i=1;i<=m;i++)
{
int u=read(),v=read(),dis=read();
add(u,v,dis);add(v,u,dis);
}
SPFA();//**求反向最短路作为估价函数h(u)**
printf("%d",A_star());
return 0;
}