K最短路問題(單源點最短路徑+A*算法)

/*
 *算法引入：
 *在單源點最短路徑問題中,實際運用時還需知道最短路徑外,次短路或者第三短路;
 *即要知道多條最短路,並排出其長度增加的順序,即爲K最短路問題;
 *
 *算法思想：
 *單源點最短路徑+高級搜索A*;
 *A*算法結合了啓發式方法和形式化方法;
 *啓發式方法通過充分利用圖給出的信息來動態地做出決定而使搜索次數大大降低;
 *形式化方法不利用圖給出的信息,而僅通過數學的形式分析;
 *
 *算法通過一個估價函數f(h)來估計圖中的當前點p到終點的距離,並由此決定它的搜索方向;
 *當這條路徑失敗時,它會嘗試其他路徑;
 *對於A*,估價函數=當前值+當前位置到終點的距離,即f(p)=g(p)+h(p),每次擴展估價函數值最小的一個;
 *
 *對於K短路算法來說,g(p)爲當前從s到p所走的路徑的長度;h(p)爲點p到t的最短路的長度;
 *f(p)的意義爲從s按照當前路徑走到p後再走到終點t一共至少要走多遠;
 *
 *爲了加速計算,h(p)需要在A*搜索之前進行預處理,只要將原圖的所有邊反向,再從終點t做一次單源點最短路徑就能得到每個點的h(p)了;
 *
 *算法步驟：
 *(1),將有向圖的所有邊反向,以原終點t爲源點,求解t到所有點的最短距離;
 *(2),新建一個優先隊列,將源點s加入到隊列中;
 *(3),從優先級隊列中彈出f(p)最小的點p,如果點p就是t,則計算t出隊的次數;
 *如果當前爲t的第k次出隊,則當前路徑的長度就是s到t的第k短路的長度,算法結束;
 *否則遍歷與p相連的所有的邊,將擴展出的到p的鄰接點信息加入到優先級隊列;
 *
 *算法測試：
 *PKU2449(Remmarguts' Date)
 *
 *題目大意：
 *求從s到t的第k短路的長度;
 */

#include<iostream>
#include<cstring>
#include<cstdlib>
#include<queue>
#include<cstdio>
#include<climits>
#include<algorithm>
using namespace std;

const int INF=0xffffff;
const int N=1010;
const int M=100010;

struct node1
{
    int to;
    int w;
    int next;
};

node1 edge1[M],edge2[M];
int head1[M],head2[M];
int idx1,idx2;
int dist[N];

struct node2
{
    int to;
    //g(p)爲當前從s到p所走的路徑的長度;h(p)爲點p到t的最短路的長度;
    int g,f;//f=g+h,f(p)的意義爲從s按照當前路徑走到p後再走到終點t一共至少要走多遠;
    bool operator<(const node2 &r ) const
    {
        if(r.f==f)
            return r.g<g;
        return r.f<f;
    }
};

void Addedge1(int u,int v,int w)
{
    edge1[idx1].w=w;
    edge1[idx1].to=v;
    edge1[idx1].next=head1[u];
    head1[u]=idx1++;
}

void Addedge2(int u,int v,int w)
{
    edge2[idx2].w=w;
    edge2[idx2].to=v;
    edge2[idx2].next=head2[u];
    head2[u]=idx2++;
}

bool SPFA(int s,int n,int head[],node1 edge[],int dist[])
{
    queue<int>Q1;
    int inq[N];
    for(int i=0; i<=n; i++)
    {
        dist[i]=INF;
        inq[i]=0;
    }
    dist[s]=0;
    Q1.push(s);
    inq[s]++;
    while(!Q1.empty())
    {
        int q=Q1.front();
        Q1.pop();
        inq[q]--;
        if(inq[q]>n)//負權環
            return false;
        int k=head[q];
        while(k>=0)
        {
            if(dist[edge[k].to]>dist[q]+edge[k].w)
            {
                dist[edge[k].to]=edge[k].w+dist[q];
                if(!inq[edge[k].to])
                {
                    inq[edge[k].to]++;
                    Q1.push(edge[k].to);
                }
            }
            k=edge[k].next;
        }
    }
    return true;
}

int A_star(int s,int t,int n,int k,int head[],node1 edge[],int dist[])
{
    node2 e,ne;
    int cnt=0;
    priority_queue<node2>Q;
    if(s==t)//當s==t時,距離爲0的路不能算在這k短路中,所以需要求k+1短路;
        k++;
    if(dist[s]==INF)
        return -1;
    e.to=s;
    e.g=0;
    e.f=e.g+dist[e.to];
    Q.push(e);

    while(!Q.empty())
    {
        e=Q.top();
        Q.pop();
        if(e.to==t)//找到一條最短路徑
        {
            cnt++;
        }
        if(cnt==k)//找到k短路
        {
            return e.g;
        }
        for(int i=head[e.to]; i!=-1; i=edge[i].next)
        {
            ne.to=edge[i].to;
            ne.g=e.g+edge[i].w;
            ne.f=ne.g+dist[ne.to];
            Q.push(ne);
        }
    }
    return -1;
}

int main()
{
    int n,m;
    //freopen("C:\\Users\\Administrator\\Desktop\\kd.txt","r",stdin);
    while(~scanf("%d%d",&n,&m))
    {
        memset(head1, -1, sizeof(head1));
        memset(head2, -1, sizeof(head2));
        idx1=idx2=0;
        int u,v,w;
        for(int i=0; i<m; i++)
        {
            scanf("%d%d%d",&u,&v,&w);
            Addedge1(u,v,w);
            Addedge2(v,u,w);
        }
        int s,t,k;
        scanf("%d%d%d",&s,&t,&k);
        SPFA(t,n,head2,edge2,dist);//以原終點t爲源點,求反向圖中t到所有點的最短距離;
        int res=A_star(s,t,n,k,head1,edge1,dist);
        printf("%d\n",res);
    }
    return 0;
}