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

然后就

真香

我不知道用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=2147483647;
int position[510];
int total,to[3000],value[3000],naxt[3000],head[810];
int f[810],v[810];
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,0,sizeof(v));
    queue<int> q;
    q.push(start);f[start]=0;v[start]=1;
    while(!q.empty())
    {
        int x,y;
        x=q.front();q.pop();v[x]=0;
        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]==0) v[y]=1,q.push(y);
            }
    }
}
int main()
{
    scanf("%d%d%d",&cow,&n,&m);
    for(int i=1;i<=cow;i++)
        scanf("%d",&position[i]);
    for(int i=1;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=1;i<=n;i++)
    {
        int dist=0;
        spfa(i);
        for(int j=1;j<=cow;j++)
            dist+=f[position[j]];
        ans=min(ans,dist);
    }
    printf("%d",ans);
    return 0;
}

【香甜的黄油 Sweet Butter】