【acwing】1127. 香甜的黄油*

开始用floyd,将牛的数量当成了点的数量将800个点看成了500个点，以为近2e8能过，显然超时了。
然后采用朴素版的Dijkstra，还是超时了因存在3重循环，接近4e8;
然后，看了大佬们的思路，他们有用堆优化的dijkstra或者spfa.
所以，从这两种方法入手。
之所以，M为3000，是因为无向边，边数要✖2

堆优化版的Dijkstra

#include <iostream>
#include <algorithm>
#include <cstring>
#include <queue>
#define x first
#define y second
using namespace std;
const int N = 3e3 + 10, INF = 0x3f3f3f3f;
typedef pair<int,int>pii;
int h[N],e[N],ne[N],w[N],idx;
// pii q[N*N];
int dis[N];
bool st[N];
int a[N];
int n,m,k;
void add(int a, int b, int c){
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}
int dijkstra(int s){
    memset(dis,0x3f,sizeof(dis));
    memset(st,0,sizeof(st));
    priority_queue<pii, vector<pii>, greater<pii>> heap;
    
    // int hh = 0, tt = 0;
    dis[s] = 0;
    // q[0] = {0,s};
    heap.push({0,s});
    while(heap.size()){
        pii t = heap.top();
        heap.pop();
        int ver = t.y, dist = t.x;
        if(st[ver]) continue;
        st[ver] = true;
        for(int i = h[ver]; i != -1; i = ne[i]){
            int j = e[i];
            if(dis[j] > dist + w[i]){
                dis[j] = dist + w[i];
                heap.push({dis[j],j});
            }
        }
    }
    int ans = 0;
    for(int i = 1; i <= k; i++){
        // int j = a[i];
        if(dis[a[i]] == 0x3f3f3f3f) return INF;
        ans += dis[a[i]];
    }
    return ans;
}
int main(){
    scanf("%d%d%d",&k,&n,&m);
    for(int i = 1; i <= k; i++) scanf("%d",&a[i]);
    // memset(g,0x3f,sizeof(g));
    memset(h,-1,sizeof(h));
    while(m--){
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        // g[a][b] = g[b][a] = min(g[a][b],c);
        add(a,b,c);
        add(b,a,c);
    }
    int ans = INF;
    for(int i = 1; i <= n; i++) ans = min(ans, dijkstra(i));
    printf("%d\n",ans);
    return 0;
}

Spfa

若使用数组模拟队列，当hh=N 以及tt==N是，需要将hh和tt置为0，达到循环队列的效果。
因队列开到m*n可能会爆空间。

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
const int N = 810, M = 3e3 + 10, INF = 0x3f3f3f3f;
int h[N],e[M],ne[M],w[M],idx;
int dis[N],a[N];
int st[N];
int n,m,k;
void add(int a, int b, int c){
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}
int spfa(int s){
    memset(dis,0x3f,sizeof(dis));
    memset(st,0,sizeof(st));
    dis[s] = 0;
    queue<int> q;
    q.push(s);
    st[s] = true;
    while(q.size()){
        int t = q.front();
        q.pop();
        st[t] = false;
        for(int i = h[t]; i != -1; i = ne[i]){
            int j = e[i];
            if(dis[j] > dis[t] + w[i]){
                dis[j] = dis[t] + w[i];
                if(!st[j]){
                    st[j] = true;
                    q.push(j);
                }
            }
        }
    }
    int ans = 0;
    for(int i = 1; i <= k; i++){
        if(dis[a[i]] == INF) return INF;
        ans += dis[a[i]];
    }
    return ans;
}
int main(){
    scanf("%d%d%d",&k,&n,&m);
    for(int i = 1; i <= k; i++) scanf("%d",&a[i]);//牛所在牧场的编号
    memset(h,-1,sizeof(h));
    while(m--){
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        add(a,b,c);
        add(b,a,c);
    }
    int ans = INF;
    for(int i = 1; i <= n; i++) ans = min(ans, spfa(i));
    printf("%d",ans);
    return 0;
}

再次总结Spfa和堆优化版的dijkstra
spfa:队列，st数组需要不断的true和false。在while(q.size())前就需要将起点置位true.若结点未进过队列，则让该结点近队列。
堆优化版的dijkstra:优先队列（小根堆：最短距离）。在队列队首pop后，判断st[ver]，若true,则continue.
若false,则置为true。