usaco3.2.7香甜的奶油

这道题，典型的最短路。

一开始求方便，用Floyd-Warshall算法，结果超时了。。。

所以，需要一种高效率的方法求最短路，有两种，一种是spfa，一种是Dijkstra的堆优化，本人只会后一种。

利用stl库里面的优先队列，储存当时的一些路，从而节省在一开始的寻找当时最短的next的时间。

具体就在代码里了。

提供两种储存边的方法（说是两种，其实差不多。。。）

#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <queue>
#include <vector>
using namespace std;
struct aaa{int hao,dist;
        bool operator < (const aaa& rhs) const{
           return dist>rhs.dist;
        }
};
priority_queue<aaa>d;
int dist[810],shu[810];
struct bbb{int from,to,d;};
vector<bbb>G;
vector<int>map[810];
int n,m,p;
int mins=99999999;
bool key[810];
int main()
{
    freopen("butter.in","r",stdin);
    freopen("butter.out","w",stdout);
    cin>>n>>p>>m;
    for(int i=1;i<=n;i++){
        int a;
        cin>>a;
        shu[a]++;
    }
    for(int i=0;i<m;i++){
        bbb kk;
        scanf("%d%d%d",&kk.from,&kk.to,&kk.d);
        G.push_back((bbb)kk);
        G.push_back((bbb)kk);
        map[G[i*2].from].push_back(2*i);
        swap(G[i*2+1].from,G[i*2+1].to);
        map[G[i*2+1].from].push_back(2*i+1);
    }
    for(int i=1;i<=p;i++){
        for(int j=1;j<=p;j++)
            {dist[j]=99999999;
            key[j]=false;}
        dist[i]=0;
        d.push((aaa){i,0});
        while(!d.empty()){
            aaa next=d.top();
            d.pop();
            if(key[next.hao])continue;
            key[next.hao]=true;
            for(int j=0;j<map[next.hao].size();j++)
            {
                bbb kkk=G[map[next.hao][j]];
                if(kkk.d+dist[next.hao]<dist[kkk.to] )
                {
                    dist[kkk.to]=kkk.d+dist[next.hao];
                    aaa l;
                    l.hao=kkk.to;
                    l.dist=dist[kkk.to];
                    d.push(l);
                }
            }
        }
        int x=0;
        for(int j=1;j<=p;j++)
            x+=dist[j]*shu[j];
        mins=min(mins,x);
    }
    cout<<mins<<endl;
    return 0;
}

#include <iostream>
#include <fstream>
#include <cstdlib>
#include <queue>
using namespace std;
struct vertex {
int dist;
bool known;
} v[801];
int nCow, nPastures, nEdge;
int cow[503];
const int INF = 0x7FFFF;
// edge
vector < int >Map[801];
vector < int >val[801];
int dijkstra(int start)
{
for (int i = 1; i <= nPastures; i++) {
v[i].dist = INF;
v[i].known = false;
}
priority_queue < pair < int, int > >heap;
heap.push(make_pair(0, start));
v[start].dist = 0;
        int u, w, cost;
while (!heap.empty()) {
u = heap.top().second;
//cout << u << endl;
heap.pop();
if (!v[u].known) {
v[u].known = true;
for (unsigned int i = 0; i < Map[u].size(); i++) {
w = Map[u][i];
if (!v[w].known)
cost = val[u][i];
if (v[w].dist > v[u].dist + cost) {
v[w].dist = v[u].dist + cost;
heap.push(make_pair(-v[w].dist, w));
}
}
}
}

        int totalDist = 0;
for (int j = 0; j <= nCow; j++)
totalDist += v[cow[j]].dist;
//cout << start << ' '  << totalDist << endl;
return totalDist;
}

int main()
{
ifstream fin("butter.txt");
        fin >> nCow >> nPastures >> nEdge;
for (int i = 0; i < nCow; i++)
fin >> cow[i];
int l, r, d;
for (int i = 0; i < nEdge; i++) {
fin >> l >> r >> d;
Map[l].push_back(r);
Map[r].push_back(l);
val[l].push_back(d);
val[r].push_back(d);
}

        int min = INF, walkDist;
for (int i = 1; i <= nPastures; i++) {
walkDist = dijkstra(i);
if (min > walkDist)
min = walkDist;
}
cout << min << endl;
return 0;
}