bzoj1598 [Usaco2008 Mar]牛跑步 ( 启发式搜索 A*算法 )

bzoj1598 [Usaco2008 Mar]牛跑步

原题地址：http://www.lydsy.com/JudgeOnline/problem.php?id=1598

题意：
BESSIE准备用从牛棚跑到池塘的方法来锻炼。但是因为她懒，她只准备沿着下坡的路跑到池塘， 然后走回牛棚。BESSIE也不想跑得太远，所以她想走最短的路经。 农场上一共有M (1 <= M <= 10,000)条路，每条路连接两个用1..N(1 <= N <= 1000)标号的地点。更方便的是，如果X>Y，则地点X的高度大于地点Y的高度。 地点N是BESSIE的牛棚；地点1是池塘。很快，BESSIE厌倦了一直走同一条路。所以她想走不同的路，更明确地讲，她想找出K (1 <= K <= 100)条不同的路经。为了避免过度劳累，她想使这K条路经为最短的K条路经。请帮助BESSIE找出这K条最短路经的长度。你的程序需要读入农场的地图， 一些从X_i到Y_i 的路经和它们的长度(X$_i$, Y$_i$, D$_i$)。 所有(X$_i$ ,Y$_i$ ,D$_i$)满足(1 <= Y$_i$< X$_i$, Y$_i$< X$_i$<= N, 1 <= D$_i$ <= 1,000,000).

Input

• 第1行: 3个数: N, M, 和K

• 第 2..M+1行: 第 i+1 行包含3个数 X$_i$,Y$_i$, 和 D$_i$, 表示一条下坡的路.

Output

• 第1..K行: 第i行包含第i最短路经的长度,或-1如果这样的路经不存在.如果多条路经有同样的长度,请注意将这些长度逐一列出.

Sample Input

5 8 7
5 4 1
5 3 1
5 2 1
5 1 1
4 3 4
3 1 1
3 2 1
2 1 1

Sample Output
1
2
2
3
6
7
-1

HINT
输出解释:
路经分别为(5-1), (5-3-1), (5-2-1), (5-3-2-1), (5-4-3-1),(5-4-3-2-1).

数据范围
1 <= M <= 10,000，1 <= N <= 1000，1 <= K <= 100
1 <= Y$_i$< X$_i$ Y$_i$ < X$_i$<= N, 1 <= D$_i$<= 1,000,000)

题解：
首先我们跑n遍最短路肯定不现实（时间长+难处理），要是能一次BFS搞定就好了。
要是暴搜肯定要优化时间，不能把所有可能路径都跑出来。
那么我们需要尽量准确，最好能先走完较短的路径，找到k个就走。

于是这时候启发式搜索登场：
我们需要一个指引我们的估价函数 f(i)，它要让我们走当前最短路所在的路。

如何准确的指出，从已走路径到当前点最后到终点的最短路呢？

建反向边，预先从终点跑次spfa( )，得到每个点为起点，到终点的最短路。

定义 估价函数$f(i)=step+dis[i]$
表示走了step距离到i点，所能达到的最短路的距离。
注意这个估价是准确的。
那么，相当于我们有了航向，只需要每次取出最小f(i)接着走，保证先走到更短的路径。用一个优先队列维护。

于是从起点开始bfs，（ i=s，step=0，dis=dis[s]入队）
每次把估价最低的已知路径取出，走一步，再把了走一步的加入优先队列。

注意新加答案是在取队首发现u==t时，而不是在进队时发现v==t时。
感谢Berry大佬的解惑。

首先，估价函数是准确的。
但是是相对整条路径最短而言。
所以当前点走的是 最优值，下一步仍然可能选择了次优值。
如果在进队时就处理，就可能错过最优解 。
eg:

此时走到u,
u–>v–>t比u—>t更短
但在走边时并未择优，造成的结果是u—>t先入队。
因此，我们要借用优先队列再排序。
所以在出队时处理。

最后注意，n是起点，1是终点。

代码：

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
#define LL long long
using namespace std;
const int N=1005;
const int M=10005;
int n,m,k,head[N],to[M],nxt[M],w[M],num=0,cnt=0;
bool inq[N];
queue<int> Q;
struct node
{
    int x; LL step,dis;
    bool friend operator<(const node &A,const node &B)
    {
        return A.step+A.dis>B.step+B.dis;
    }
    node(){}
    node(int x,LL step,LL dis):x(x),step(step),dis(dis){}
};
priority_queue<node> P;
LL dis[N],ans[N];
struct edge
{
    int u,v,w;
}e[M];
void init()
{
    memset(head,0,sizeof(head));
    num=0;
}
void build(int u,int v,int ww)
{
    num++;
    to[num]=v;
    nxt[num]=head[u];
    w[num]=ww;
    head[u]=num;
}
void getdis()
{
    for(int i=0;i<=n;i++) dis[i]=1e11;
    memset(inq,0,sizeof(inq));
    dis[1]=0;
    while(!Q.empty()) Q.pop();
    Q.push(1); inq[1]=1;
    while(!Q.empty())
    {
        int u=Q.front(); Q.pop(); inq[u]=0;
        for(int i=head[u];i;i=nxt[i])
        {
            int v=to[i];
            if(dis[v]>dis[u]+1LL*w[i])
            {
                dis[v]=dis[u]+1LL*w[i];
                if(!inq[v])
                {
                    inq[v]=1;
                    Q.push(v);
                }
            }
        }   
    }   
}
void bfs()
{
    P.push(node(n,0,dis[n]));
    while(!P.empty())
    {
        if(cnt==k) return;
        node tmp=P.top(); P.pop();
        int u=tmp.x; LL step=tmp.step;
        if(u==1) ans[++cnt]=step;
        if(cnt==k) return;
        for(int i=head[u];i;i=nxt[i])
        {
            int v=to[i];
            LL d=step+w[i];
            P.push(node(v,d,dis[v]));
        }
    }
}
int main()
{
    scanf("%d%d%d",&n,&m,&k);
    init();
    for(int i=1;i<=m;i++) 
    {
         scanf("%d%d%d",&e[i].u,&e[i].v,&e[i].w);
         build(e[i].v,e[i].u,e[i].w);
    }
    getdis();
    init();
    for(int i=1;i<=m;i++) 
    build(e[i].u,e[i].v,e[i].w);
    bfs();
    for(int i=1;i<=cnt;i++)
    printf("%lld\n",ans[i]);    
    for(int i=1;i<=k-cnt;i++)
    printf("-1\n"); 
    return 0;
}