k短路与A*

了解A*前先从一个比较直接的思路看起

我们用一个堆来维护一系列的二元组 $(u,dis)$
u表示当前节点编号，dis表示从起点s到u的某条路径长

初始时堆中只有 $(s,0)$
之后不断从堆顶取出dis值最小的二元组 $(u,dis)$
遍历所有与u连接的结点 $v_i$
将 $(v_i,dis+dis(u,v_i))$ 插入堆
当u第k次被从堆中取出时，就得到了从s到u的第k短路

A*求k短路中，大体框架就是像上述这样堆+BFS 维护
但因为估价函数的存在，时间效率大大提高
换言之，在A*算法中
每次从堆顶取出的是估价最小的结点

什么是估价函数呢
我们假设从起始状态到目标状态的总代价可以分为两部分
1.从起始状态到当前状态所需代价，记为 $g(u)$
2.从当前状态到目标状态的预估代价，记为 $h(u)$
那么有总代价 $f(n)=g(u)+h(u)$

显然为了使 $f(n)$ 最小
需要综合考虑 $g(u)$ 与 $h(u)$
因为有可能存在情况
当前代价很小，但未来将付出的代价有很大
也有可能当前代价很大，但将来要付出代价很小

前述朴素思路中就是只考虑了当前代价 $g(u)$ 最小(当前dis最小)
即相当于预估代价总是 $h(u)=0$
所以造成了搜索效率低

所以我们依然将从s到当前结点u距离dis作为 $g(u)$
然后在A*开始前先从终点沿着反向边跑一次最短路
得到从终点到每个节点的最短距离 $d[u]$ 作为估价函数 $h(u)$

有了估价函数之后上述算法就要可以改为
用优先队列维护三元组 $(u, g, f)$ ，含义同上述
初始时优先队列中只有 $(s, 0, 0+d[n])$

接着每次取出 $f$ 值最小的结点 (若存在 $f$ 先等则取 $g$ 最小) 记为 $(u, g, f)$
遍历所有与u连接的结点 $v_i$
向优先队列中插入所有 $(v_i, g+dis(u,v_i), g+dis(u,v_i)+d[v_i])$
当结点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;
}

猜你喜欢