codevs 1269 匈牙利游戏 SPFA+次短路

匈牙利游戏之最短路径

最新推荐文章于 2025-12-02 19:01:55 发布

转载最新推荐文章于 2025-12-02 19:01:55 发布 · 170 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/Loi-Vampire/p/6017066.html

文章标签：

#python

本文介绍了一个趣味性的编程问题——匈牙利游戏，参赛者需要在布达佩斯复杂的单向街道网络中寻找从起点到终点的严格次短路径。文章详细解释了问题背景、输入输出要求，并提供了一段实现SPFA算法的C++代码示例。

题目描述 Description
Welcome to the Hungary Games! The streets of Budapest form a twisted network of one-way streets.

欢迎来到匈牙利游戏！布达佩斯（匈牙利首都）的街道形成了一个弯曲的单向网络。

You have been forced to join a race as part of a “Reality TV” show
where you race through these streets, starting at the Sz´echenyi
thermal bath (s for short) and ending at the Tomb of G¨ ul Baba (t for
short).

你被强制要求参加一个赛跑作为一个TV秀的一部分节目，比赛中你需要穿越这些街道，从s开始，到t结束。

Naturally, you want to complete the race as quickly as possible,
because you will get more promo- tional contracts the better you
perform.

很自然的，你想要尽快的完成比赛，因为你的比赛完成的越好，你就能得到更多的商业促销合同。

However, there is a catch: any person who is smart enough to take a shortest s-t route will be thrown into the P´alv¨olgyi cave system and kept as a national treasure. You would like to avoid this fate, but still be as fast as possible. Write a program that computes a strictly-second-shortest s-t route.

但是，有一个需要了解的是，如果有人过于聪明找到从s到t的最短路线，那么他就被扔到国家极品人类保护系统中作为一个国家宝藏收藏起来。你显然要避免这种事情的发生，但是也想越快越好。写一个程序来计算一个从s到t的严格次短路线吧。

Sometimes the strictly-second-shortest route visits some nodes more than once; see Sample Input 2 for an example.

有的时候，严格次短路线可能访问某些节点不止一次。样例2是一个例子。

输入描述 Input Description
The ﬁrst line will have the format N M, where N is the number of nodes in Budapest and M is the number of edges. The nodes are 1,2,…,N; node 1 represents s; node N represents t. Then there are M lines of the form A B L, indicating a one-way street from A to B of length L. You can assume that A != B on these lines, and that the ordered pairs (A,B) are distinct.

第一行包含两个整数N和M，N代表布达佩斯的节点个数，M代表边的个数。节点编号从1到N。1代表出发点s，N代表终点t。接下来的M行每行三个整数A B L，代表有一条从A到B的长度为L的单向同路。你可以认为A不等于B，也不会有重复的(A,B)对。

输出描述 Output Description
Output the length of a strictly-second-shortest route from s to t. If there are less than two possible lengths for routes from s to t, output −1.

输出从s到t的严格次短路的长度。如果从s到t的路少于2条，输出-1。

样例输入 Sample Input
样例输入1：

4 6

1 2 5

1 3 5

2 3 1

2 4 5

3 4 5

1 4 13

样例输入2：

2 2

1 2 1

2 1 1

样例输出 Sample Output
样例输出1：

11

样例输出2：

3

数据范围及提示 Data Size & Hint
对于样例1：

There are two shortest routes of length 10 (1 → 2 → 4,1 → 3 → 4) and
the strictly-second- shortest route is 1 → 2 → 3 → 4 with length 11.

对于样例2：

The shortest route is 1 → 2 of length 1, and the strictly-second route
is 1 → 2 → 1 → 2 of length 3.

跟最短路做法差不多，另开一个数组记录次短路即可。

如果 from 的最短路不能更新 to 的最短路，但是可以更新 to 的次短路，那就让它更新去吧，我们也不用再储存以前的 to 的次短路值，因为那就是第 3 短路了没用。

如果 from 的最短路可以更新 to 的最短路，那我们让 to 的次短路等于更新之前 to 的最短路，就是把 to 的最短路移到次短路上，因为我们有更短了路了。

如果 from 的次短路可以更新 to 的次短路那也让它更新去吧。

而且初始值要尽量大，因为有的数据会比21474836还大
悲剧啊……

#include<iostream>
#include<cstdio>
#include<queue>
#include<algorithm>
#include<cstring>
using namespace std;
const int MAXN = 2000000;
struct Edge
{
    int from, to, cost;
}es[MAXN];
int first[MAXN], nxt[MAXN] , tot = 1;
long long zd[MAXN], cd[MAXN];       //怒开 long long
bool used[MAXN];
queue < int > q;

void build(int f, int t, int d)
{
    es[++tot].from = f;
    es[tot].to = t;
    es[tot].cost = d;
    nxt[tot] = first[f];
    first[f] = tot;
}

void spfa(int s)
{
    zd[s] = 0;
    q.push(s);
    used[s] = 1;
    while(!q.empty())
    {
        int u = q.front();
        q.pop();
        used[u] = 0;
        for(int i = first[u]; i != -1; i = nxt[i])
        {
            int v = es[i].to;
            if(zd[v] > zd[u] + es[i].cost)
            {
                cd[v] = zd[v];
                zd[v] = zd[u] + es[i].cost;
                if(!used[v])
                {
                    q.push(v);
                    used[v] = 1;
                }
            }
            else if(cd[v] > zd[u] + es[i].cost && zd[v] < zd[u] + es[i].cost)
            {
                cd[v] = zd[u] + es[i].cost;
                if(!used[v])
                {
                    q.push(v);
                    used[v] = 1;
                }
            }
            else if(cd[v] > cd[u] + es[i].cost )
            {
                cd[v] = cd[u] + es[i].cost;
                if(!used[v])
                {
                    q.push(v);
                    used[v] = 1;
                }
            }
        }
    }
}

int main()
{
    int n, m;
    scanf("%d%d", &n, &m);
    memset(first, -1, sizeof(first));
    for(int i = 1; i <= m; i++)
    {
        int s, e, c;
        scanf("%d%d%d", &s, &e, &c);
        build(s, e, c);
    }
    for(int i = 1; i <= n; i++)
    {
        zd[i] = 214748362222;
        cd[i] = 214748362222;
    }
    zd[1] = 0;
    spfa(1);
    if(cd[n] < 214748362222)
        printf("%lld", cd[n]);
    else
        printf("-1");
    return 0;
}