UVA - 10986 Sending email(堆优化的dijkstra||SPFA)

There are n SMTP servers connected by network cables. Each of the m cables connects two computers
and has a certain latency measured in milliseconds required to send an email message. What
is the shortest time required to send a message from server S to server T along a sequence of cables?
Assume that there is no delay incurred at any of the servers.
Input
The first line of input gives the number of cases, N. N test cases follow. Each one starts with a line
containing n (2 ≤ n ≤ 20000), m (0 ≤ m ≤ 50000), S (0 ≤ S < n) and T (0 ≤ T < n). S ̸= T. The
next m lines will each contain 3 integers: 2 different servers (in the range [0, n − 1]) that are connected
by a bidirectional cable and the latency, w, along this cable (0 ≤ w ≤ 10000).
Output
For each test case, output the line ‘Case #x:’ followed by the number of milliseconds required to send
a message from S to T. Print ‘unreachable’ if there is no route from S to T.
Sample Input
3
2 1 0 1
0 1 100
3 3 2 0
0 1 100
0 2 200
1 2 50
2 0 0 1
Sample Output
Case #1: 100
Case #2: 150
Case #3: unreachable

最短路的几个算法好像就堆优的迪杰斯特拉最熟悉了，但是这个题还是卡了，主要是一些细节，邻接表存无向图存两边所以数组大小要开到二倍不然会WA，还有注意输入输出格式

#include <bits/stdc++.h>
using namespace std;
const int N = 1e7 + 5;
typedef long long ll;
typedef unsigned long long ull;
const int INF = 0x3f3f3f3f;
typedef pair<int, int> PII;

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

void dijkstra(int x)
{

    dist[x] = 0;
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    heap.push({0, x});

    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 != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > distance + w[i])
            {
                dist[j] = distance + w[i];
                heap.push({dist[j], j});
            }
        }
    }
}
int main()
{
    int t, kase = 0;
    cin >> t;
    while (t--)
    {
        memset(h, -1, sizeof h);
        memset(dist, 0x3f, sizeof dist);
        memset(st, false, sizeof st);
        idx = 0;
        int n, m, c, d;
        cin >> n >> m >> c >> d;
        for (int i = 0; i < m; i++)
        {
            int u, v, w;
            cin >> u >> v >> w;
            add(u, v, w);
            add(v, u, w);
        }
        if (c > d)
            swap(c, d);
        dijkstra(c);

        if (dist[d] == INF)
        {
            printf("Case #%d: unreachable\n", ++kase);
        }
        else
        {
            printf("Case #%d: %d\n", ++kase, dist[d]);
        }
    }

    return 0;
}