poj 2449 Remmarguts' Date 启发式搜索 A*算法

做这个题算是学了学spfa算法，一开始感觉spfa和dij好像；dij找最小点松弛，spfa就是一个一个的松弛，松到不能松。

求S到T的第K短路

思路：这个算法的思路是从源点S优雅的暴力跑bfs，用优先队列来装跑的过程中点的位置以及跑的距离，优先队列按照来装跑的距离最短的排序，然后随着跑跑的距离就越来越长，那总会跑到T点吧，这个时候你的cnt+1，直到第k次跑到T点的时候就是第K短路了。看着很迷，但是为什么说是优雅呢，就是该算法的核心，A*就是Astar算法

1.首先，从终点T跑一边Spfa，用数组d[ ]记录每一个点到终点T的最短距离。

2.然后，从起点S跑bfs，边跑边记录跑的距离F与位置now，优雅的就是，当我们每次跑到一个位置的时候，其实从位置now到T点的最短的距离G又确定了，G=F+d[now],然后我们结构体装进去位置，已经跑的距离，从该点跑到T点的最短距离{now,F，G}，并且按照G点排序，当我们走到终点now=T，这个时候就是第一次跑到G点的时候，那么F就是第一短的距离，那么跑到第k次终点T，此时的F就是第K短路。

参考博客：https://blog.csdn.net/z_mendez/article/details/47057461  超级清晰的介绍

代码如下：

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
#include<math.h>
#include<set>
#include<stack>
#include<vector>
#include<map>
#include<queue>
#define myself i,l,r
#define lson i<<1
#define rson i<<1|1
#define Lson i<<1,l,mid
#define Rson i<<1|1,mid+1,r
#define half (l+r)/2
#define inff 0x3f3f3f3f
#define lowbit(x) x&(-x)
#define me(a,b) memset(a,b,sizeof(a))
#define min4(a,b,c,d) min(min(a,b),min(c,d))
#define min3(x,y,z) min(min(x,y),min(y,z))
#define max4(a,b,c,d) max(max(a,b),max(c,d))
#define max3(x,y,z) max(max(x,y),max(y,z))
typedef long long ll;
const double eqs=1e-9;
const double pi=acos(-1.0);
const double E=2.718281828459;
using namespace std;
const int maxm=1e5+5;
const int maxn=1005;
int d[maxn],head[maxn],rhead[maxn];
int vis[maxn],n,m,t,k;
struct Edge
{
    int to,p,val;
}edge[maxm<<1],redge[maxm<<1];
struct node
{
    int now,g,f;
    bool friend operator<(node s,node e)
    {
        if(s.f==e.f) return s.g>e.g;
        return s.f>e.f;
    }
};
void init()
{
    for(int i=0;i<=n;i++)
    {
        d[i]=inff;
        head[i]=rhead[i]=-1;
        vis[i]=0;
    }
}
void add(int u,int v,int val,int sign)
{
    redge[sign]=Edge{u,rhead[v],val};
    rhead[v]=sign;
    edge[sign]=Edge{v,head[u],val};
    head[u]=sign;
}
void Spfa(int u)
{
    queue<int> q;
    d[u]=0;
    q.push(u);
    while(!q.empty())
    {
        u=q.front();
        q.pop();
        vis[u]=0;
        for(int i=rhead[u];~i;i=redge[i].p)
        {
            int v=redge[i].to;
            if(d[v]>d[u]+redge[i].val)
            {
                d[v]=d[u]+redge[i].val;
                if(!vis[v])
                {
                    q.push(v);
                    vis[v]=1;
                }
            }
        }
    }
}
int Astar(int s)
{
    priority_queue<node>q;
    int cnt=0;
    if(s==t) k++;///如果是起点等于终点k++
    if(d[s]==inff) return -1;
    node a,next;
    a=node{s,0,d[s]};
    q.push(a);
    while(!q.empty())
    {
        a=q.top();
        q.pop();
        if(a.now==t)
        {
            cnt++;
            if(cnt==k)
                return a.g;
        }
        for(int i=head[a.now];i!=-1;i=edge[i].p)
        {
            next.now=edge[i].to;
            next.g=a.g+edge[i].val;
            next.f=next.g+d[next.now];
            q.push(next);
        }
    }
    return -1;
}
int main()
{
    int s,x,y,z;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        init();
        for(int i=0;i<m;i++)
        {
            scanf("%d%d%d",&x,&y,&z);
            add(x,y,z,i);
        }
        scanf("%d%d%d",&s,&t,&k);
        Spfa(t);
        printf("%d\n",Astar(s));
    }
    return 0;
}