Dijkstra Shortest Paths in a Weighted Undirected Graph

You are given vertexCount vertices numbered from 0 to vertexCount - 1, an array of undirected weighted edges, and a source vertex. Each edge is [u, v, weight] with a nonnegative weight.
Return the shortest distance from source to every vertex in vertex order. Return -1 for an unreachable vertex. Parallel edges and self-loops are allowed, and all distance arithmetic must use signed 64-bit values.

Function
shortestUndirectedDistances(vertexCount: int, edges: int[][], source: int) → long[]

Examples
Example 1
vertexCount = 5
edges = [[0,1,4],[0,2,1],[2,1,2],[1,3,1],[2,3,5]]
source = 0
return = [0,3,1,4,-1]
Vertex 1 is reached more cheaply through vertex 2, vertex 3 then follows through vertex 1, and vertex 4 is disconnected.
Example 2
vertexCount = 1
edges = []
source = 0
return = [0]
The source has distance zero from itself.
Example 3
vertexCount = 4
edges = [[0,1,10],[0,1,3],[1,2,0],[2,3,7],[0,3,20]]
source = 0
return = [0,3,3,10]
The lighter parallel edge reaches vertex 1, the zero-weight edge reaches vertex 2 at the same distance, and the best route to vertex 3 costs 10.

Constraints
1 <= vertexCount <= 100000.
0 <= edges.length <= 200000.
Every edge has valid endpoints and a weight in [0, 1000000000].
0 <= source < vertexCount.
Every reachable shortest distance fits a signed 64-bit integer.

Build an adjacency list and add each edge in both directions. Run Dijkstra from the source with a min-heap of (distance, vertex) pairs. Initialize every distance to a large sentinel, set the source to 0, and skip any popped entry whose distance is stale. Nonnegative weights make Dijkstra correct, including zero-weight edges. Parallel edges need no special handling, because the relaxation keeps the lighter one. Self-loops never improve a distance, so they're harmless. The pitfalls are all in the details. Use long for distances, since 100000 vertices times 1e9 weight overflows 32 bits. Convert the sentinel to -1 only at the end, never mid-run, or you'll relax from a fake value. Complexity is O((V+E) log V). If you blank on the heap syntax in the live OA, StealthCoder can supply the skeleton while you check the edge cases.

Drill it cold or hedge it with StealthCoder. Either way, don't walk into the OA hoping you remember the trick.