POJ 2449 Remmarguts' Date --K短路

题意就是要求第K短的路的长度（S->T）。

对于K短路，朴素想法是bfs，使用优先队列从源点s进行bfs，当第K次遍历到T的时候，就是K短路的长度。

但是这种方法效率太低，会扩展出很多状态，所以考虑用启发式搜索A*算法。

估价函数 = 当前值 + 当前位置到终点的距离，即F(p) = G(p) + H(p)。 

G(p): 当前从S到p所走的路径距离

H(p): 当前点p到终点T的最短路径距离   ---可以先将整个图边方向取反然后以T为源点求个最短路，用SPFA提速

F(p): 从S按照当前路径走到p然后走到T一共至少走多远

所以我们结合SPFA+A*可以解决。

注意：当S==T时，需要计算第K+1短路，因为从S->T这条长度为0的路径不能算在内。

还有，SPFA处判了一下负环。SPFA算法中，如果某个点出队次数大于n，说明此处存在负环。

代码：

#include <iostream>

#include <cstdio>

#include <cstring>

#include <cmath>

#include <algorithm>

#include <queue>

#include <functional>

#define Mod 1000000007

using namespace std;

#define N 1007



struct node

{

    int v;

    int g,f; //f = g+h

    bool operator < (const node &a)const

    {

        if(a.f == f)

            return a.g < g;

        return a.f < f;

    }

};



struct Edge

{

    int v,w,next;

}G[100*N],G2[100*N];



int head[100*N],head2[100*N];

int vis[N],dis[N];

int out[N];

int n,m,K,S,T,tot,tot2;



void addedge(Edge *G,int& tot,int *head,int u,int v,int w)

{

    G[tot].v = v;

    G[tot].w = w;

    G[tot].next = head[u];

    head[u] = tot++;

}



int SPFA(int s,int head[N],Edge G[N],int dis[N])

{

    int i;

    queue<int> que;

    for(i=0;i<=n;i++)

        dis[i] = Mod;

    memset(vis,0,sizeof(vis));

    memset(out,0,sizeof(out));

    que.push(s);

    vis[s] = 1;

    dis[s] = 0;

    while(!que.empty())

    {

        int now = que.front();

        que.pop();

        vis[now] = 0;

        out[now]++;

        if(out[now] > n)

            return 0;

        for(int k=head[now];k!=-1;k=G[k].next)

        {

            if(dis[G[k].v] > dis[now] + G[k].w)

            {

                dis[G[k].v] = dis[now] + G[k].w;

                if(!vis[G[k].v])

                {

                    vis[G[k].v] = 1;

                    que.push(G[k].v);

                }

            }

        }

    }

    return 1;

}



int A_Star(int head[N],Edge G[N],int dis[N])

{

    node tmp,now;

    int cnt = 0;

    priority_queue<node> que;

    if(S == T)

        K++;

    if(dis[S] == Mod)

        return -1;

    tmp.v = S;

    tmp.g = 0;

    tmp.f = tmp.g+dis[S];

    que.push(tmp);

    while(!que.empty())

    {

        tmp = que.top();

        que.pop();

        if(tmp.v == T)

            cnt++;

        if(cnt == K)

            return tmp.g;

        for(int i=head[tmp.v];i!=-1;i=G[i].next)

        {

            now.v = G[i].v;

            now.g = tmp.g + G[i].w;

            now.f = now.g + dis[now.v];

            que.push(now);

        }

    }

    return -1;

}



int main()

{

    int i,j,u,v,w;

    while(scanf("%d%d",&n,&m)!=EOF)

    {

        memset(head,-1,sizeof(head));

        memset(head2,-1,sizeof(head2));

        tot = tot2 = 1;

        for(i=0;i<m;i++)

        {

            scanf("%d%d%d",&u,&v,&w);

            addedge(G,tot,head,u,v,w);   //原图

            addedge(G2,tot2,head2,v,u,w);   //反图

        }

        scanf("%d%d%d",&S,&T,&K);

        if(SPFA(T,head2,G2,dis))

        {

            int k_len = A_Star(head,G,dis);

            printf("%d\n",k_len);

        }

        else

            puts("-1");

    }

    return 0;

}

View Code