Pick the algorithm from the edge weights, never from habit:

BFS and 0-1 BFS

• BFS pops vertices in order of edge count; set dist[v] when v is first pushed, and a cell is never queued twice.
• 0-1 BFS: a 0-edge push_fronts the neighbour, a 1-edge push_backs it. The deque holds at most two distance values, in order, so its front is always a closest vertex.

deque<int> dq{src};
dist[src] = 0;
while (!dq.empty()) {
    int u = dq.front(); dq.pop_front();
    for (auto [v, w] : adj[u])
        if (dist[u] + w < dist[v]) {
            dist[v] = dist[u] + w;
            w == 0 ? dq.push_front(v) : dq.push_back(v);
        }
}

Dijkstra, the contest way

vector<ll> dist(n + 1, LLONG_MAX);
priority_queue<pair<ll,int>, vector<pair<ll,int>>, greater<>> pq;
dist[src] = 0;
pq.push({0, src});
while (!pq.empty()) {
    auto [d, u] = pq.top(); pq.pop();
    if (d > dist[u]) continue;              // stale pair: lazy deletion
    for (auto [v, w] : adj[u])
        if (d + w < dist[v]) {
            dist[v] = d + w;
            pq.push({dist[v], v});
        }
}

• greater<> turns the max-heap into a min-heap; the distance goes first in the pair so it decides the order.
• The heap cannot lower a key, so an improvement pushes a new pair; the old one is skipped later by d > dist[u].
• Path sums are long long: a path of 10^5 edges of 10^9 is 10^14.