P2901 [USACO08MAR]牛慢跑Cow Jogging

最新推荐文章于 2024-02-13 23:45:14 发布

卿与

最新推荐文章于 2024-02-13 23:45:14 发布

阅读量255

点赞数 2

分类专栏：图论文章标签： K短路 A*算法

本文链接：https://blog.csdn.net/zfq17796515982/article/details/100573357

版权

图论专栏收录该内容

9 篇文章 0 订阅

订阅专栏

题目描述传送门

Bessie has taken heed of the evils of sloth and has decided to get fit by jogging from the barn to the pond several times a week. She doesn't want to work too hard, of course, so she only plans to jog downhill to the pond and then amble back to the barn at her leisure.

Bessie also doesn't want to jog any too far either, so she generally takes the shortest sequence of cow paths to get to the pond. Each of the M (1 <= M <= 10,000) cow paths connects two pastures

conveniently numbered 1..N (1 <= N <= 1000). Even more conveniently, the pastures are numbered such that if X>Y then the cow path from pasture X to pasture Y runs downhill. Pasture N is the barn (at the top of the hill) and pasture 1 is the pond (at the bottom).

Just a week into her regimen, Bessie has begun to tire of always taking the same route to get to the pond. She would like to vary her route by taking different cow paths on different days. Specifically, Bessie would like to take exactly K (1 <= K <= 100) different routes for variety. To avoid too much exertion, she wants these to be the K shortest routes from the barn to the pond. Two routes are considered different if they comprise different sequences of cow paths.

Help Bessie determine how strenuous her workout will be by determining the lengths of each of the K shortest routes on the network of pastures. You will be supplied a list of downhill cow paths from X_i to Y_i along with the cow path's length: (X_i, Y_i, D_i) where (1 <= Y_i < X_i; Y_i < X_i <= N). Cowpath i has length D_i (1 <= D_i <= 1,000,000).

贝西尝到了懒惰的恶果——为了减肥，她不得不决定每周花几次时间在牛棚和池塘之间慢跑。但贝西并不想太累，所以她打算只跑从牛棚到池塘的下坡路，然后再慢慢地从池塘走回牛棚。

同时，贝西也不想跑得太远，所以她只想沿着通向池塘的最短路径跑步。在牧场里，每条道路连接了两个结点（这些结点的编号为1到N，1≤N≤1000）。另外，如果X>?，说明结点X的地势要高于Y，所以下坡的道路是从X通向Y的，贝西所在牛棚的编号为N（最高点），池塘的编号为1（最低点）。

而然，一周之后，贝西对单调的路线厌倦了，她希望每天可以跑不同的路线，比如说，最好能有K (1≤K≤100)种不同的选择。为了不至于跑得太累，她希望这Ｋ条路径是从牛棚到池塘的最短的Ｋ条路径。

请帮助贝西算算她的运动量，即找出网络里最短的K条路径的长度。假设每条道路用(Xi,Yi,Di)表示，其中1≤Yi＜Xi≤N，表示这条道路从Xi出发到Yi，其长度为Di (1≤Di≤1,000,000)。

输入格式

* Line 1: Three space-separated integers: N, M, and K

* Lines 2..M+1: Line i+1 describes a downhill cow path using three space-separated integers: X_i, Y_i, and D_i

输出格式

* Lines 1..K: Line i contains the length of the i-th shortest route or -1 if no such route exists. If a shortest route length occurs multiple times, be sure to list it multiple times in the output.

输入输出样例

输入 #1

输出 #1

说明/提示

The routes are (5-1), (5-3-1), (5-2-1), (5-3-2-1), (5-4-3-1),

(5-4-3-2-1).

思路：K短路径模板题，先建立反向图，找到各个顶点到目的点的最短距离（可以用Dijkstra或者是spfa,看个人喜好了)。然后再用A*算法（广度优先搜索+加剪枝），一点点得出最短的前K条路经。其中用于剪枝的评估函数是f(u) = dis0[u] + dis[u]，其中 dis0[u] 表示：N~u的最短路径，dis[u] 表示 u~1的最短路径。根据评估函数的从小到大依次求出图的前K短路径.

AC代码：

#include <bits/stdc++.h>

using namespace std;
#define io ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)
#define mset(a, n) memset(a, n, sizeof(a))
#define fi first
#define se second
#define mp make_pair
#define pb push_back
typedef long long ll;
typedef pair<int,int> PII;
typedef pair<int,PII> PPI;
typedef pair<ll, ll> PLL;
const int maxn =  1e3+5;

int V, E, K; int tot;
int dis[maxn];
bool vis[maxn];

struct node{
    int to;
    int val;
    node(){}
    node(int _to, int _val): to(_to), val(_val){}
    bool operator < (const node &a) const {
        return val+dis[to] > a.val+dis[a.to];
    }
};
struct Edges{
    int to;
    int val;
    Edges(){}
    Edges(int _to, int _val): to(_to), val(_val){}
};
vector<Edges> G[maxn], lG[maxn];
int ans[maxn];

void addedge(int u, int v, int val){
    G[u].pb(Edges(v, val));
    lG[v].pb(Edges(u, val));
}

void spfa(){
    mset(vis,false);
    mset(dis,0x3f3f);

    queue<int> Q;
    Q.push(1);
    vis[1] = true;
    dis[1] = 0;

    while(!Q.empty()){
        int u = Q.front(); Q.pop();
        vis[u] = false;
        for(int i=0;i<lG[u].size();i++){
            int v = lG[u][i].to, val = lG[u][i].val;
            if(dis[v] > dis[u]+val){
                dis[v] = dis[u]+val;
                if(!vis[v]){
                    Q.push(v);
                    vis[v] = true;
                }
            }
        }
    }

}

void a_star(){
    priority_queue<node> Q;
    Q.push(node(V,0));

    while(!Q.empty()){
        node nw = Q.top(); Q.pop();
        if(nw.to == 1){
            tot++;
            ans[tot] = nw.val;
            if (tot>K) return;
        }
        for(int i = 0; i<G[nw.to].size();i++){
            Q.push(node(G[nw.to][i].to, nw.val+G[nw.to][i].val));
        }
    }
    return;
}

int main(){
    scanf("%d%d%d", &V, &E, &K);
    for(int i=1;i<=E;i++){
        int u,v,val;
        scanf("%d%d%d", &u, &v, &val);
        addedge(u,v,val);
    }
    mset(ans,-1);
    spfa();
    tot = 0;
    a_star();
    for(int i=1;i<=K;i++){
        printf("%d\n", ans[i]);
    }
    return 0;
}