A*(A - star) - Remmarguts’ Date - POJ - 2449

A*(A - star) - Remmarguts’ Date - POJ - 2449

题意：

给定一张N个点（编号1,2…N），M条边的有向图，求从起点S到终点T的第K短路的长度，路径允许重复经过点或边。

注意： 每条最短路中至少要包含一条边。

输入格式
第一行包含两个整数N和M。

接下来M行，每行包含三个整数A,B和L，表示点A与点B之间存在有向边，且边长为L。

最后一行包含三个整数S,T和K，分别表示起点S，终点T和第K短路。

输出格式
输出占一行，包含一个整数，表示第K短路的长度，如果第K短路不存在，则输出“-1”。

数据范围
$1\le S,T\le N\le 1000,0\le M\le 10^5,1\le K\le 1000,1\le L\le 100$
输入样例：

2 2
1 2 5
2 1 4
1 2 2

输出样例：

14

---

分析：

$要求从S到T的第k短路径。$

$对于每个点u，我们计算从起点S到u的距离d[u]，设从u到终点T的最短距离为dist[u]，$

$以d[u]+dist[u]为第一关键字，用小根堆来扩展。$

$于是启发函数通过dijkstra实现，求源点为T的最短路径，存入dist数组。$

$当终点T第k次出队，此时的路径长度为第k短路。$

具体落实:

$①、反向建图，以T为源点跑一遍dijkstra，得到dist估价函数。$

$②、正向建图，astar算法得到第k短路。$

注意：

$本题要求每条路径至少包含一条边，当起点与终点相同时，必须要经过其他点再回到起点才算一条路径。$

$这种情况将k自增1，排除掉距离为0的最短路径的情况。$

代码：

#include<iostream>
#include<cstring>
#include<cstdio>
#include<queue>

#define P pair<int,int>
#define Pi pair<int,P>
#define x first
#define y second

using namespace std;

const int N=1010,M=2e5+10;

int n,m,k,S,T;
bool st[N];
int e[M],ne[M],h[N],rh[N],w[M],idx;
int dist[N];

void add(int h[],int a,int b,int c)
{
    e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}

int dijkstra()
{
    memset(dist,0x3f,sizeof dist);
    dist[T]=0;

    priority_queue<P,vector<P>,greater<P> > heap;
    heap.push({0,T});

    while(heap.size())
    {
        P t=heap.top();
        heap.pop();

        int ver=t.y;
        if(st[ver]) continue;
        st[ver]=true;

        for(int i=rh[ver];~i;i=ne[i])
        {
            int j=e[i];
            if(dist[j]>dist[ver]+w[i])
            {
                dist[j]=dist[ver]+w[i];
                heap.push({dist[j],j});
            }
        }
    }
}

int astar()
{
    priority_queue<Pi,vector<Pi>,greater<Pi> > heap;
    heap.push({dist[S],{0,S}});		//1.估计最短距离下限 2.已经走过的距离 3.节点编号

    int cnt=0;
    while(heap.size())
    {
        Pi t=heap.top();
        heap.pop();

        int ver=t.y.y,distance=t.y.x;
        if(ver==T) cnt++;
        if(cnt==k) return distance;

        for(int i=h[ver];~i;i=ne[i])
        {
            int j=e[i];
            heap.push({distance+w[i]+dist[j],{distance+w[i],j} });
        }
    }

    return -1;
}

int main()
{
    memset(h,-1,sizeof h);
    memset(rh,-1,sizeof rh);

    scanf("%d%d",&n,&m);
    for(int i=0;i<m;i++)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        add(h,a,b,c);
        add(rh,b,a,c);
    }

    scanf("%d%d%d",&S,&T,&k);
    if(S==T) k++;  //

    dijkstra();
    printf("%d\n",astar());

    return 0;
}