【CS 1557】热浪(Bellman_ford、Spfa、Spfa-slf三杀)

最新推荐文章于 2023-03-06 22:55:53 发布

Loi_Chairman

最新推荐文章于 2023-03-06 22:55:53 发布

阅读量321

点赞数 1

CC 4.0 BY-SA版权

分类专栏： ===图论=== 最短路

本文链接：https://blog.youkuaiyun.com/qq_36693514/article/details/78011408

===图论=== 同时被 2 个专栏收录

10 篇文章

订阅专栏

最短路

5 篇文章

订阅专栏

本文介绍了一个经典的图论题目——寻找两城镇间运送牛奶的最短路径。使用Bellman-Ford算法和SPFA算法实现，并提供两种算法的代码实现细节。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

刷怪区

一个经典到成为图论板子的题目，曾经学长们挂起的旋风就是“一言不合刷起热浪”

时间限制: 1 s
空间限制: 256000 KB
题目等级 : 钻石 Diamond

题目描述 Description

德克萨斯纯朴的民眾们这个夏天正在遭受巨大的热浪！！！他们的德克萨斯长角牛吃起来不错，可是他们并不是很擅长生產富含奶油的乳製品。Farmer John此时以先天下之忧而忧，后天下之乐而乐的精神，身先士卒地承担起向德克萨斯运送大量的营养冰凉的牛奶的重任，以减轻德克萨斯人忍受酷暑的痛苦。
FJ已经研究过可以把牛奶从威斯康星运送到德克萨斯州的路线。这些路线包括起始点和终点先一共经过T (1 <= T <= 2,500)个城镇，方便地标号為1到T。除了起点和终点外地每个城镇由两条双向道路连向至少两个其它地城镇。每条道路有一个通过费用（包括油费，过路费等等）。
给定一个地图，包含C (1 <= C <= 6,200)条直接连接2个城镇的道路。每条道路由道路的起点Rs，终点Re (1 <= Rs <= T; 1 <= Re <= T)，和花费(1 <= Ci <= 1,000)组成。求从起始的城镇Ts (1 <= Ts <= T)到终点的城镇Te(1 <= Te <= T)最小的总费用。

输入描述 Input Description

第一行: 4个由空格隔开的整数: T, C, Ts, Te

第2到第C+1行: 第i+1行描述第i条道路。有3个由空格隔开的整数: Rs, Re和Ci

输出描述 Output Description
一个单独的整数表示从Ts到Te的最小总费用。数据保证至少存在一条道路。

样例输入 Sample Input

7 11 5 4
2 4 2
1 4 3
7 2 2
3 4 3
5 7 5
7 3 3
6 1 1
6 3 4
2 4 3
5 6 3
7 2 1

样例输出 Sample Output

数据范围及提示 Data Size & Hint

5->6->1->4 (3 + 1 + 3)

思路：
最早做过的题目之一，也是被大佬们刷的最惨烈的题目之一

首先来一份短的bellman_ford
这个是真的皮，相比起来代码长度真的短

bellman_ford 如下：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
const int sz = 100000 + 5;
int f,t,v,tot;
int n,m,s,e;
int d[sz];
struct ed{
    int f,t,v;
}l[sz];

inline void buile(int f,int t,int v)
{
    l[++tot]=(ed){f,t,v};
}

void bellman()
{
    memset(d,0x3f,sizeof(d));
    d[s]=0;
    while(true)
    {
        bool bh=0;
        for(int i=1;i<=2*m;++i)
        {       
        ed e=l[i];
            if(d[e.f]!=0x3f&&d[e.t]>d[e.f]+e.v)
            {
                d[e.t]=d[e.f]+e.v;
                bh=1;
            }
        }
        if(!bh) break;
    }
    return;
}

int main()
{
    cin>>n>>m>>s>>e;
    for(int i=1;i<=m;++i)
    {
        cin>>f>>t>>v;
        buile(f,t,v);
        buile(t,f,v);
    }
    bellman();
    cout<<d[e]<<endl;
    return 0;
}

然后是一份普通的spfa版的，也很好用
spfa如下：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>

using namespace std;
const int sz = 100000 + 5;
int fir[sz],nxt[sz<<1],tot;
int dis[sz];
bool use[sz];

struct edge
{
    int f,t,v;
}l[sz << 1];

inline void init()
{
    memset(fir,-1,sizeof(fir));
    tot = 0;
}

inline void build(int f,int t,int v)
{
    l[++ tot] = (edge) {f,t,v};
    nxt[tot] = fir[f];
    fir[f] = tot;
}

queue <int> q;
void spfa(int s)
{
    memset(use,0,sizeof(use));
    memset(dis,0x3f,sizeof(dis));
    while(!q.empty()) q.pop();

    q.push(s);
    use[s] = 1;
    dis[s] = 0;

    while(!q.empty())
    {
        int u = q.front();
        q.pop();
        use[u] = 0;

        for(int i = fir[u];i != -1;i = nxt[i])
        {
            int v = l[i].t;
            if(dis[v] > dis[u] + l[i].v)
            {
                dis[v] = dis[u] + l[i].v;
                if(!use[v])
                    q.push(v);
                use[v] = 1;
            }
        }
    }
}

int main()
{
    init();
    int n,m,s,e;
    int rs,re,rv;
      scanf("%d%d%d%d",&n,&m,&s,&e);
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&rs,&re,&rv);
        build(rs,re,rv);
        build(re,rs,rv);
    }
    spfa(s);
    printf("%d",dis[e]);
    return 0;
}

然后再来份用双端队列操作过的Spfa_slf，这个就有玄学优化，对于一些卡spfa的题目来说搞乱顺序各种乱跑来跳过
spfa_slf如下：

#include<cstdio>
#include<iostream>
#include<queue>
#include<cstring>
using namespace std;
const int sz = 50010;

int fir[sz],nxt[sz<<1],tot=0;
int dis[sz];
bool use[sz];
int n,m,s,e,f,t,v;
struct edge{
    int f,t,v;
}l[sz<<1];

inline void build(int f,int t,int v)
{
    l[++tot]=(edge){f,t,v};
    nxt[tot]=fir[f];
    fir[f]=tot;
}
deque<int>q;
void spfa(int s)
{
    memset(use,0,sizeof(use));
    memset(dis,0x3f,sizeof(dis));
    dis[s]=0;
    use[s]=1;
    q.push_front(s);
    while(!q.empty())
    {
        int u=q.front();
        q.pop_front();
        use[u] = 0;
        for(int i=fir[u];i!=-1;i=nxt[i])
        {
            int v=l[i].t;
            if(dis[v]>dis[u]+l[i].v)
            {
                dis[v]=dis[u]+l[i].v;
                if(q.empty()||dis[v]<dis[q.front()])
                    q.push_front(v);
                else q.push_back(v);
            use[v]=1;
            }
        }
    }
}
int main()
{
    memset(fir,-1,sizeof(fir));
    cin>>n>>m>>s>>e;
    for(int i=1;i<=m;++i)
    {
        cin>>f>>t>>v;
        build(f,t,v);
        build(t,f,v);
    }
    spfa(s);
    cout<<dis[e]<<endl;
    return 0;
}