Why is this Dijkstra code correct (node processing)? - dijkstra

Question

https://bradfieldcs.com/algos/graphs/dijkstras-algorithm/
I don't quite understand why this is true. They claim that by checking current_distance > distances[current_vertex], we process each node exactly one time. However, that doesn't look right to me since the last two lines in the while loop are
distances[neighbor] = distance
heapq.heappush(pq, (distance, neighbor))
So I would think every time a node is pushed to the heap, if it's popped again and we observe current_vertex, current_vertex (the popped node and weight), distances[neighbor] will equal to the current_distance. Therefore, the node will get re-processed and not skipped as previously claimed.
import heapq
def calculate_distances(graph, starting_vertex):
distances = {vertex: float('infinity') for vertex in graph}
distances[starting_vertex] = 0
pq = [(0, starting_vertex)]
while len(pq) > 0:
current_distance, current_vertex = heapq.heappop(pq)
# Nodes can get added to the priority queue multiple times. We only
# process a vertex the first time we remove it from the priority queue.
if current_distance > distances[current_vertex]:
continue
for neighbor, weight in graph[current_vertex].items():
distance = current_distance + weight
# Only consider this new path if it's better than any path we've
# already found.
if distance < distances[neighbor]:
distances[neighbor] = distance
heapq.heappush(pq, (distance, neighbor))
return distances
Can someone tell me what I'm missing here? I know every node is supposed to be processed only once but I don't see why that code makes it so. And I don't see where I'm wrong.

Answer 1

The vertex can be added into the heap multiple times. Each time it's added to the heap with different distance. Now, you finally process it. Since it's a priority queue, you will process a pair (vertex, distance) with a smallest distance.
Two ideas:
For each vertex only one of existing (present in the heap) pairs can be processed.
After the vertex is processed, no new pairs for this vertex will be added.
First, a distance to a vertex always decreases. It means that for a given vertex there is only one (vertex, distance) that can be triggered: namely, the one with the smallest distance (unless later a pair with even smaller distance arrives). In other words, when the vertex is processed, all its other pairs in the heap won't be processed.
After the vertex is processed, its distance can't change. The reason for this is that Dijkstra selects a vertex with smallest distance; and since all edge weights are positive and all other vertices have bigger distance, the distance to the processed vertex can't decrease. Therefore, a new pair for the vertex can't appear in the heap.