POJ2449 【第k短路/A*】

题目链接：http://poj.org/problem?id=2449

题目大意：

给出n个点，m条有向边，最后一行给出起点到终点的第k短路。求长度。

题解思路：

这是我第一道第k短路题以及A*算法的使用。

这是一篇A*算法讲的非常好的博客：https://blog.csdn.net/weixin_44489823/article/details/89382502

将A*运用到求第k短路上实际上与文章中的A*是有所不同的。但是精髓没有改变，精髓是寻路时，选择 f 值最小的点，用来避免寻找无用的路径。在A*算法中本应该对所经过的点进行标记，就像是bfs时对已经经过的点进行标记，但在第k短路中不可以，因为需要重复走各个需要走的点。那么在每次走到终点一定是当前一次的最短路，在下一次再次走到终点时，就是第2次最短路，以此类推，第k短路就是第k次到达终点时所走的总路程。

对于h评估函数，在第k短路是终点到各个点的距离，对原图建一个反向图，以终点为起边来跑一遍最短路即可得到h数组。

对于g函数，是所走过的距离，即原图起点到该点的距离。

代码如下：

 #include<stdio.h>
 #include<string.h>
 #include<queue>
 #include<algorithm>
 #define mem(a, b) memset(a, b, sizeof(a))
 using namespace std;
 typedef long long ll;
 const int MAXN = 1e3 + ;
 const int MAXM = 1e5 + ;
 const int inf = 0x3f3f3f3f;

 int n, m;    //n个点 m条有向边
 int head[MAXN], cnt, r_head[MAXN], r_cnt;
 int vis[MAXN];
 ll h[MAXN]; 

 struct Edge
 {
     int to, next, w;
 }e[MAXM], r_e[MAXM];

 struct Node
 {
     int pot;
     ll g, h;
     bool operator < (const Node &a)const //优先选择f值小的点 A*算法精髓所在
     {
         return g + h > a.g + a.h;
     }
 }node;

 void add(int a, int b, int c)
 {
     cnt ++;
     e[cnt].to = b;
     e[cnt].next = head[a];
     e[cnt].w = c;
     head[a] = cnt;
 }

 void r_add(int a, int b, int c) //反向边 与正向边的编号一致
 {
     r_cnt ++;
     r_e[r_cnt].to = b;
     r_e[r_cnt].next = r_head[a];
     r_e[r_cnt].w = c;
     r_head[a] = r_cnt;
 }

 int spfa(int st, int ed)  //反向图 跑 h 评估函数(在这里也就是终点到该点的最短距离) A*算法精髓
 {
     mem(h, inf), mem(vis, );
     queue<int> Q;
     while(!Q.empty())    Q.pop();
     vis[st] = ;
     h[st] = ;
     Q.push(st);
     while(!Q.empty())
     {
         int a = Q.front();
         Q.pop();
         vis[a] = ;
         for(int i = r_head[a]; i != -; i = r_e[i].next)
         {
             int to = r_e[i].to;
             if(h[to] > h[a] + r_e[i].w * 1ll)
             {
                 h[to] = h[a] + r_e[i].w * 1ll;
                 if(!vis[to])
                 {
                     vis[to] = ;
                     Q.push(to);
                 }
             }
         }
     }
     return h[ed] != inf;
 }

 ll A_star(int st, int ed, int k) //优先队列 优先选择f值小的点 跑正向图
 {
     int num = ;
     priority_queue<Node> QQ;
     while(!QQ.empty())    QQ.pop();
     node.pot = st, node.g = , node.h = h[st];
     QQ.push(node);
     while(!QQ.empty())
     {
         Node a = QQ.top();
         QQ.pop();
 //        printf("%d\n", a.pot);
         if(a.pot == ed)  //如果第k次找到终点 就得出了答案
         {
             num ++;
             if(num == k)
                 return a.g + a.h;
         }
         for(int i = head[a.pot]; i != -; i = e[i].next)
         {
             int to = e[i].to;
             node.pot = to;
             node.g = a.g + e[i].w * 1ll;
             node.h = h[to];
             QQ.push(node);
         }
     }
     return -;
 }

 int main()
 {
     scanf("%d%d", &n, &m);
     mem(head, -), cnt = ;
     mem(r_head, -), r_cnt = ;
     for(int i = ; i <= m; i ++)
     {
         int a, b, c;
         scanf("%d%d%d", &a, &b, &c);
         add(a, b, c);
         r_add(b, a, c);
     }
     int a, b, k; //a 到 b 的第 k 短路
     scanf("%d%d%d", &a, &b, &k);
     if(a == b)
         k ++;
     if(!spfa(b, a))
         printf("-1\n"); //若起点到终点本身就不连通 就不存在第k短路 输出-1
     else
         printf("%lld\n", A_star(a, b, k));
     return ;
 }

第k短路模板