Dijkstra---用堆优化解决问题

《堆优化解决类似多源最短路问题》
1 1127. 香甜的黄油

农夫John发现了做出全威斯康辛州最甜的黄油的方法：糖。

把糖放在一片牧场上，他知道 N 只奶牛会过来舔它，这样就能做出能卖好价钱的超甜黄油。

当然，他将付出额外的费用在奶牛上。

农夫John很狡猾，就像以前的巴甫洛夫，他知道他可以训练这些奶牛，让它们在听到铃声时去一个特定的牧场。

他打算将糖放在那里然后下午发出铃声，以至他可以在晚上挤奶。

农夫John知道每只奶牛都在各自喜欢的牧场（一个牧场不一定只有一头牛）。

给出各头牛在的牧场和牧场间的路线，找出使所有牛到达的路程和最短的牧场（他将把糖放在那）。

数据保证至少存在一个牧场和所有牛所在的牧场连通。

输入格式
第一行: 三个数：奶牛数 N，牧场数 P，牧场间道路数 C。

第二行到第 N+1 行: 1 到 N 头奶牛所在的牧场号。

第 N+2 行到第 N+C+1 行：每行有三个数：相连的牧场A、B，两牧场间距 D，当然，连接是双向的。

输出格式
共一行，输出奶牛必须行走的最小的距离和。

数据范围
1≤N≤500,
2≤P≤800,
1≤C≤1450,
1≤D≤255
输入样例：
3 4 5
2
3
4
1 2 1
1 3 5
2 3 7
2 4 3
3 4 5
输出样例：
8

这道题如果直接用floyd来写的话，时间复杂度是O（p^3）;

是5.12*1e8;很可能超时

但是如果对于每一个点都用堆优化的Dijkstra算法，时间复杂度是O（p*c*logn^2）;

还可以

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#include <vector>
using namespace std;
typedef pair<int, int> PII;
const int INF = 0x3f3f3f3f, N = 510;
vector<PII> g[2*N];//注意这里，我不知道为啥写成vector<vector<int,int>>g就会读入时，读不进
int n, p, c;
int wherecows[N];
int dist[2 * N];
bool st[2 * N];
void Dijkstra(int str)
{
    memset(dist, 0x3f, sizeof(dist));
    memset(st, false, sizeof(st));
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    dist[str] = 0;
    heap.push({0, str});
    while (heap.size())
    {
        int v = heap.top().second;
        heap.pop();
        if (st[v])
            continue;
        st[v] = true;

        for (int i = 0; i < g[v].size(); i++)
        {
            int node = g[v][i].first;
            int w = g[v][i].second;
            if (!st[node])
            {
                dist[node] = min(dist[node], dist[v] + w);
                heap.push({dist[node], node});
            }
        }
    }
}
int main()
{
    cin >> n >> p >> c;
    for (int i = 1; i <= n; i++)
    {
        cin >> wherecows[i];
    }
    int a, b, w;
    for (int i = 1; i <= c; i++)
    {
        cin >> a >> b >> w;
        g[a].push_back({b,w});
        g[b].push_back({a,w});
    }
    int mindist = INF;
    for (int i = 1; i <= p; i++)
    {
        Dijkstra(i);
        int nowdist = 0;
        for (int i = 1; i <= n; i++)
        {
            nowdist += dist[wherecows[i]];
        }
        mindist = min(mindist, nowdist);
    }
    printf("%d", mindist);
    return 0;
}
这段代码会超时，很神奇，我不知道怎么回事

 《堆优化的使用细节》

1135. 新年好
 
重庆城里有 n 个车站，m 条 双向 公路连接其中的某些车站。

每两个车站最多用一条公路连接，从任何一个车站出发都可以经过一条或者多条公路到达其他车站，但不同的路径需要花费的时间可能不同。

在一条路径上花费的时间等于路径上所有公路需要的时间之和。

佳佳的家在车站 1，他有五个亲戚，分别住在车站 a,b,c,d,e。

过年了，他需要从自己的家出发，拜访每个亲戚（顺序任意），给他们送去节日的祝福。

怎样走，才需要最少的时间？

输入格式
第一行：包含两个整数 n,m，分别表示车站数目和公路数目。

第二行：包含五个整数 a,b,c,d,e，分别表示五个亲戚所在车站编号。

以下 m 行，每行三个整数 x,y,t，表示公路连接的两个车站编号和时间。

输出格式
输出仅一行，包含一个整数 T，表示最少的总时间。

数据范围
1≤n≤50000,
1≤m≤105,
1<a,b,c,d,e≤n,
1≤x,y≤n,
1≤t≤100
输入样例：
6 6
2 3 4 5 6
1 2 8
2 3 3
3 4 4
4 5 5
5 6 2
1 6 7
输出样例：
21

#include <iostream>
#include <algorithm>
#include <cstring>
#include <queue>
using namespace std;
typedef pair<int, int> PII;
const int N = 50010, INF = 0x3f3f3f3f;
int n, m, target[6];
int x, y, t;
vector<PII> g[N];
int dist[6][N];//dist[i][j]表示点target[i]到点j的最短距离是dist[i][j];
bool st[N], vis[6];
int ans = INF;
void Dijkstra(int x, int node)
{
    memset(st, false, sizeof(st));
    dist[x][node] = 0;
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    heap.push({0, node});
    while (heap.size())
    {
        int v = heap.top().second;
        heap.pop();
        if (st[v])
            continue;
        st[v] = true;

        //注意堆优化千万不能够用这个来，
        //也就是说，不能够用g[N][N]来保存图，因为用这个数据结构保存图
        //意为着一定会用到下面这种方式来更新路径
        //但这种方式，铁定时间复杂度是O(nm),m是路径条数，n是点数
        //y总所说的O(mlogn)是我们手写堆，定死其中元素个数是n
        //但是用STL中的堆，无法把控堆中总个数，可能其中个数是m
        //这时其实是O(mlogm),但在稀疏图中一般m<n^2
        //可以看做O(mlogm)约等于O(mlogn)

        /*  for (int i=1;i<=n;i++)
         {
             if (!st[i] && dist[x][i]>dist[x][v]+g[v][i])
             {
                 dist[x][i]=dist[x][v]+g[v][i];
                 heap.push({})
             }
         } */
         //分析这个时间复杂度：
         //首先这个for循环，最多总共也就是执行了m次
         //heap.size()总的也就是m次
         //堆自身内部排序logm(logn)
         //所以总时间复杂度O(mlogm)（O(mlogn)）;
        for (int i = 0; i < g[v].size(); i++)
        {
            int lnode = g[v][i].second;
            int w = g[v][i].first;
            if (!st[lnode])
            {
                dist[x][lnode] = min(dist[x][lnode], dist[x][v] + w);
                heap.push({dist[x][lnode], lnode});
            }
        }
    }
}
void dfs(int pre, int u, int road)
{
    if (road >= ans)
        return;
    if (u > 5)
        ans = road;
    for (int i = 1; i <= 5; i++)
    {
        if (!vis[i])
        {
            int thisnode = target[i];
            vis[i] = true;
            int way;
            if (pre == 0)
                way = dist[i][1];
            else
                way = dist[pre][target[i]];
            dfs(i, u + 1, road + way);
            vis[i]=false;
        }
    }
}
int main()
{
    memset(dist, 0x3f, sizeof(dist));
    cin >> n >> m;
    for (int i = 1; i <= 5; i++)
        cin >> target[i];
    for (int i = 1; i <= m; i++)
    {
        scanf("%d%d%d", &x, &y, &t);
        g[x].push_back({t, y});
        g[y].push_back({t, x});
    }
    for (int i = 1; i <= 5; i++)
        Dijkstra(i, target[i]);
    memset(vis, false, sizeof(vis));
    dfs(0, 1, 0);//上一个点是...，现在要枚举的是第...个点，现在的总路程是...
    cout<<ans;
    return 0;
}