[USACO Mar08] 牛跑步

[USACO Mar08] 牛跑步
时间限制：1 s 内存限制：128 MB
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).

输入格式:
第1行: 3个数: N, M, 和K
第 2..M+1行: 第 i+1 行包含3个数 X_i, Y_i, 和 D_i, 表示一条下坡的路.
样例输入
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
输出格式:
第1..K行: 第i行包含第i最短路经的长度,或-1如果这样的路经不存在.如果多条路经有同样的长度,请注意将这些长度逐一列出.
样例输出
1
2
2
3
6
7
-1
输出解释:
路径分别为(5-1), (5-3-1), (5-2-1), (5-3-2-1), (5-4-3-1),(5-4-3-2-1).

K短路问题

第一种解法：Dij+A*

#include<cstdio>
#include<queue>
#include<cstring>
using namespace std;
namespace cat{
    const int maxn = 10000 + 10 ;
    void read(int &x){
        x=0;char ch;
        while(ch=getchar(),ch<'!');
        while(x=10*x+ch-'0',ch=getchar(),ch>'!');
    }
    struct Edge{
        int next,to,dis;
    }G[maxn<<1];
    int head[maxn],from[maxn],to[maxn],dis[maxn];
    int val[maxn];
    int cnt = 1,n,m,K;
    void add(int u,int v,int dis){
        G[++cnt].to = v;
        G[cnt].dis = dis;
        G[cnt].next = head[u];
        head[u] = cnt;
    }
    struct Node{
        int num,dist,g,h;
        Node(int x,int y){
            num=x;dist=y;
        }
        Node(int x,int y,int z){
            num = x;g=y;h=z;
            dist = g+h;
        }
        bool operator < (const Node &x) const {
            return dist > x.dist;
        }
    };
    void dijkstra(int s){
        priority_queue<Node>Q;
        memset(dis,127/3,sizeof(dis));
        dis[s] = 0;
        Q.push( Node(s,0) );
        while(!Q.empty()){
            Node t = Q.top();Q.pop();
            int x = t.num ;
            if( t.dist != dis[t.num] ) continue;
            for(int i=head[x];i;i=G[i].next){
                if( dis[G[i].to] > dis[x] + G[i].dis ){
                    dis[G[i].to] = dis[x] + G[i].dis;
                    Q.push( Node(G[i].to,dis[G[i].to]) );
                }
            }
        }
    }
    void A_star(int s,int t,int k){
        priority_queue<Node>Q;
        Q.push( Node(s,0,dis[s]) );
        while( !Q.empty() ){
            Node x = Q.top();Q.pop();
            if( x.num == t ){
                printf("%d\n",x.g);
                k--;
                if( !k ) return;
            }
            for(int i=head[x.num];i;i=G[i].next){
                Q.push(Node(G[i].to,x.g+G[i].dis,dis[G[i].to]));
            }
        }
        for(int i=1;i<=k;i++) printf("-1\n");
        return;
    }
    int doo(){
        freopen("cowjog.in","r",stdin);
        freopen("cowjog.out","w",stdout);
        int k;
        read(n);read(m);read(k);
        for(int i=1;i<=m;i++){
            read(from[i]);read(to[i]);read(val[i]);
            add(to[i],from[i],val[i]);
        }
        int s = n,t = 1;
        dijkstra(t);
        memset(G,0,sizeof(G));
        memset(head,0,sizeof(head));
        cnt = 1;
        for(int i=1;i<=m;i++){
            add(from[i],to[i],val[i]);
        }
        A_star(s,t,k);
    }
}
int ans = cat::doo();
int main(){;}

第二种解法：拓扑排序

#include<cstdio>
#include<queue>
#include<stack>
using namespace std;
priority_queue<int> que[1005];
int n,m,k,ind[1005];
int head[1005],sz=1;
struct E {
    int to,w,nxt;
}ed[10005];
void add_edge(int u,int v,int c) {
    ed[sz].to=v;
    ed[sz].w=c;
    ed[sz].nxt=head[u];
    head[u]=sz++;
}
stack<int> S;
int tmp[105],t=0;
void topo() {
    for (int i=1;i<=n;i++) if (!ind[i]) S.push(i);
    que[n].push(0);
    while (!S.empty()) {
        int v=S.top();S.pop();
        if (v==1) {
            break;
        }
        t=0;
        while (!que[v].empty()) {
            tmp[++t]=que[v].top();
            que[v].pop();
        }
        for (int i=head[v];i;i=ed[i].nxt) {
            int p=ed[i].to;
            for (int j=1;j<=t;j++) {
                que[p].push(ed[i].w+tmp[j]);
            }
            while (que[p].size()>k) {
                que[p].pop();
            }
            if (!--ind[p]) S.push(p);
        }
    }
    int r=k-que[1].size();
    t=0;
    while (!que[1].empty()) {
        tmp[++t]=que[1].top();
        que[1].pop();
    }
    while (t) {
        printf("%d\n",tmp[t--]);
    }
    for (int i=0;i<r;i++) printf("-1\n");
}
int main() {
    freopen("cowjog.in","r",stdin);
    freopen("cowjog.out","w",stdout);
    scanf("%d%d%d",&n,&m,&k);
    int a,b,c;
    for (int i=1;i<=m;i++) {
        scanf("%d%d%d",&a,&b,&c);
        add_edge(a,b,c);
        ind[b]++;
    }
    topo();
    return 0;
}