K短路（A*+SPFA）

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
const int MAX_V = 1100;
const int MAX_E = 110000;
const int INF = 0x3f3f3f3f;

struct ENode
{
    int to;
    int w;
    int Next;
};
ENode edegs[MAX_E];
ENode edegs1[MAX_E]; //存反图;
int Head[MAX_V], Head1[MAX_V], tnt, tnt1;
void Add_ENode (int a, int b, int w)
{
    ++ tnt;
    edegs[tnt].to= b;
    edegs[tnt].w= w;
    edegs[tnt].Next= Head[a];
    Head[a]= tnt;
//    ++ tnt;  //无向图
//    edegs[tnt].to= a;
//    edegs[tnt].w= w;
//    edegs[tnt].Next= Head[b];
//    Head[b]= tnt;
}
void Add_ENode1 (int a, int b, int w)
{
    /**建反向图*/
    ++ tnt1;
    edegs1[tnt1].to= b;
    edegs1[tnt1].w= w;
    edegs1[tnt1].Next= Head1[a];
    Head1[a]= tnt1;
//    ++ tnt1;  //无向图
//    edegs1[tnt1].to= a;
//    edegs1[tnt1].w= w;
//    edegs1[tnt1].Next= Head1[b];
//    Head1[b]= tnt1;
}

int Dis[MAX_V];
bool visit[MAX_V]; //是否已经遍历过;
int que[MAX_V]; // 模拟队列;
int outque[MAX_V]; //记录每个点出队列的次数，防止有负边，保证无负边的图可以省略;
bool SPFA(int s, int n)
{
    /**SPFA处理反向图，预处理出Dis[]*/
    /*s：起点； n：点的总数*/
    int iq; //队列中元素个数;
    memset(Dis, INF, sizeof(Dis));
    memset(visit, false, sizeof(visit));
    memset(outque, 0, sizeof(outque));
    iq= 0;
    que[iq ++]= s;
    visit[s]= true;
    Dis[s]= 0;
    int i= 0;
    while (i< iq)
    {
        int u= que[i];
        visit[u]= false;
        outque[u] ++;
        if (outque[u]> n) return false; //当一个点进出队列超过n 次，必然有负边存在;

        for (int k= Head1[u]; k!= -1; k= edegs1[k].Next)
        {
            /*bfs,和Dijkstra相似*/
            int v= edegs1[k].to;
            if (Dis[v]> Dis[u]+ edegs1[k].w)
            {
                Dis[v]= Dis[u]+ edegs1[k].w;
                if (! visit[v])
                {
                    visit[v]= true;
                    que[iq ++]= v;
                }
            }
        }
        i ++;
    }
    return true;
}

struct Node
{
    int from;
    int g; //g表示到当前点的路径长度
    int f; //f=g+dis dis表示当前点到终点的最短路径，即之前的预处理
    bool operator < (const Node &r) const
    {
        if (r.f== f) return r.g- g< 0;
        return r.f- f< 0;
    }
};
int A_star (int s, int t, int n, int k)
{
    Node e, ne;
    int cnt= 0;
    priority_queue<Node> que;
    if (s== t) k ++;
    if (Dis[s]== INF) return -1;
    e.from= s;
    e.g= 0;
    e.f= e.g+ Dis[e.from];
    que.push(e);
    while (! que.empty())
    {
        e= que.top();
        que.pop();
        if (e.from== t) cnt ++;
        if (cnt== k) return e.g;
        for (int i= Head[e.from]; i!= -1; i= edegs[i].Next)
        {
            ne.from= edegs[i].to;
            ne.g= e.g+ edegs[i].w;
            ne.f= ne.g+ Dis[ne.from];
            que.push(ne);
        }
    }
    return -1;
}

void into()
{
    /**初始化*/
    memset(Head,-1,sizeof(Head));
    memset(Head1,-1,sizeof(Head1));
    tnt= -1; tnt1= -1;
}

int main()
{
    int n, m, k;
    int a, b, w;
    while (~ scanf("%d %d %d", &n, &m, &k))
    {
        into();
        for (int i= 0; i< m; i ++)
        {
            scanf("%d %d %d", &a, &b, &w);
            Add_ENode(a, b, w);
            Add_ENode1(b, a, w);  //建反图
        }
        SPFA(n, n); //处理出从终点到其他点的最短路径距离;
        int far= A_star(1, n, n, k);
        printf("%d
", far);
    }
    return 0;
}