【香甜的黄油 Sweet Butter】

【香甜的黄油 Sweet Butter】

洛谷P1828

https://www.luogu.org/problemnew/show/P1828

JDOJ 1803

https://neooj.com/oldoj/problem.php?id=1803

一眼就看出来是个最短路，看题目这么短就觉得是个裸的

然后就

真香

我不知道用dijkstra会被卡掉，但是我运气好第一遍写的就是SPFA就过了。这篇题解就给大家分析一下各最短路算法以及这道题为什么适用SPFA。

floyd算法

这个东西轻易不要用，因为是O（n^3）的，很容易就会爆掉，但是真的想用也没问题，看一下数据范围，一般不超过500都可以（如果是100-200的就比较稳了，500以上的还是慎重）. 搭配邻接矩阵就很好用。

dijkstra算法

单源最短路最常见的算法，时间复杂度是O（n^2）的，但是这题就不能用

为什么呢？？？？

因为要枚举每个点啊！！那复杂度就是O（n^3）的了，简直是找死......

所以我们只能出其最后一策了

SPFA算法

名字很高大上，事实上的确很快，加了个队列的数据结构，非常好理解，时间复杂度是O（km）（k约等于2）的，跟边的数量有关，适合

稀疏图（边少）

而dj的复杂度跟点有关，所以可以搞

稠密图（边多）

综上所述，这道题的时间复杂度就是O（nmk）的，就可以方方便便地AC了。

TALK LESS,SHOW ME THE CODE.

#include<cstdio>
#include<cstring>
#include<queue>
#include<algorithm>
using namespace std;
int cow,n,m,ans=;
int position[];
int total,to[],value[],naxt[],head[];
int f[],v[];
void add(int x,int y,int z)
{
    to[++total]=y;
    value[total]=z;
    naxt[total]=head[x];
    head[x]=total;
}
void spfa(int start)
{
    memset(f,0x3f,sizeof(f));
    memset(v,,sizeof(v));
    queue<int> q;
    q.push(start);f[start]=;v[start]=;
    while(!q.empty())
    {
        int x,y;
        x=q.front();q.pop();v[x]=;
        for(int i=head[x];i;i=naxt[i])
            if(f[y=to[i]]>f[x]+value[i])
            {
                f[y]=f[x]+value[i];
                if(v[y]==) v[y]=,q.push(y);
            }
    }
}
int main()
{
    scanf("%d%d%d",&cow,&n,&m);
    for(int i=;i<=cow;i++)
        scanf("%d",&position[i]);
    for(int i=;i<=m;i++)
    {
        int x,y,z;
        scanf("%d%d%d",&x,&y,&z);
        add(x,y,z);
        add(y,x,z);
    }
    for(int i=;i<=n;i++)
    {
        int dist=;
        spfa(i);
        for(int j=;j<=cow;j++)
            dist+=f[position[j]];
        ans=min(ans,dist);
    }
    printf("%d",ans);
    return ;
}

学过了Dijkstra堆优化之后，用DIJ也可以AC。

没有学习DIJ堆优化的请进入以下链接~

https://www.cnblogs.com/fusiwei/p/11390537.html

代码如下：

#include<cstdio>
#include<queue>
#include<algorithm>
#include<cstring>
using namespace std;
int n,p,c,ans=1e9;
int pos[];
int tot,to[],val[],nxt[],head[];
int dist[];
priority_queue<pair<int,int> >q;
void add(int x,int y,int z)
{
    to[++tot]=y;
    val[tot]=z;
    nxt[tot]=head[x];
    head[x]=tot;
}
void dijkstra(int start)
{
    memset(dist,0x3f,sizeof(dist));
    dist[start]=;
    q.push(make_pair(,start));
    while(!q.empty())
    {
        while(!q.empty() && -q.top().first>dist[q.top().second])
            q.pop();
        if(q.empty())
            return;
        int x=q.top().second;
        q.pop();
        for(int i=head[x];i;i=nxt[i])
        {
            int y=to[i];
            if(dist[y]>dist[x]+val[i])
            {
                dist[y]=dist[x]+val[i];
                q.push(make_pair(-dist[y],y));
            }
        }
    }
}
int main()
{
    scanf("%d%d%d",&n,&p,&c);
    for(int i=;i<=n;i++)
        scanf("%d",&pos[i]);
    for(int i=;i<=c;i++)
    {
        int x,y,z;
        scanf("%d%d%d",&x,&y,&z);
        add(x,y,z);
        add(y,x,z);
    }
    for(int i=;i<=p;i++)
    {
        int dis=;
        dijkstra(i);
        for(int j=;j<=n;j++)
            dis+=dist[pos[j]];
        ans=min(ans,dis);
    }
    printf("%d",ans);
    return ;
}