【天梯赛】L3-005 垃圾箱分布(堆优化版dijkstra)

与PAT甲级1072题加油站类似，坑点还是最后的结果需要加1e-8，1000个点可能不需要堆优化，朴素版dijkstra应该就可以，我用的堆优化版本是可以AC的。
1072 Gas Station

#include <bits/stdc++.h>

using namespace std;

typedef pair<int, int> PII;
const int N = 999999, INF = 0x3f3f3f3f;
int e[N], ne[N], h[N], idx, w[N];
int n, k, m, S, T, maxDist;
int dist[N];
bool st[N];
int maxD, bestPos, sum; // 最长的最短距离, 最佳位置编号, 距离和

void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}

int get(string x)
{
    if(x[0] == 'G') return stoi(x.substr(1)) + n;
    return stoi(x);
}

void dijkstra(int &minDist, int &sumDist)
{
    memset(dist, 0x3f, sizeof dist);
    memset(st, false, sizeof st);
    dist[S] = 0;
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    heap.push({0, S});
    while(heap.size())
    {
        auto t = heap.top();
        heap. pop();
        int ver = t.second, distance = t.first;
        if(st[ver]) continue;
        st[ver] = true;
        for(int i = h[ver]; ~i; i = ne[i])
        {
            int j = e[i];
            if(dist[j] > dist[ver] + w[i])
            {
                dist[j] = dist[ver] + w[i];
                heap.push({dist[j], j});
            }
        }
    }
    for(int i = 1; i <= n; i++)
    {
        if(dist[i] > maxDist)
        {
            minDist = INF, sumDist = -1;
            break;
        }
        minDist = min(minDist, dist[i]), sumDist += dist[i];
    }

}

int main()
{
    memset(h, -1, sizeof h);

    scanf("%d%d%d%d", &n, &k, &m, &maxDist);
    while(m --)
    {
        string a, b;
        int c;
        cin >> a >> b >> c;
        int e = get(a), f = get(b);
        add(e, f, c);
        add(f, e, c);
    }
    for(int i = n + 1; i <= n + k; i++)
    {
        S = i;
        int d1 = INF, d2 = 0; // minDist, sumDist
        dijkstra(d1, d2);
        if(d1 == INF) continue;
        if(d1 > maxD) maxD = d1, bestPos = i - n, sum = d2;
        if(d1 == maxD && d2 < sum) bestPos = i - n, sum = d2;
    }
    if(bestPos == 0) puts("No Solution");
    else printf("G%d\n%d.0 %.1f", bestPos, maxD, (double)sum / n + 1e-6);
}