Question

Following algorithm belongs to Dijsktra's Shortest path algorithm: PLEASE SHOW THE RUNNING TIME OF THE EACH LINE OF THE ALGORITHM AND DETERMINE THE RUNNING TIME OF THE ALGORITHM BY SUMMING UP THEM

while current_node != end:

visited.add(current_node)

destinations = graph.edges[current_node]

weight_to_current_node = shortest_paths[current_node][1]

for next_node in destinations:

weight = graph.weights[(current_node, next_node)] + weight_to_current_node

if next_node not in shortest_paths:

shortest_paths[next_node] = (current_node, weight)

else:

current_shortest_weight = shortest_paths[next_node][1]

if current_shortest_weight > weight:

shortest_paths[next_node] = (current_node, weight)

next_destinations = {node: shortest_paths[node] for node in shortest_paths if node not in visited}

if not next_destinations:

return "Route Not Possible"

# next node is the destination with the lowest weight

current_node = min(next_destinations, key=lambda k: next_destinations[k][1])

Answer 1

The while loop here goes to every node there it iterates N times.

In djikstra basically we check each node and its corresponding node and the path between them to see if that's the shortest path or not.
So we iterate for all the nodes that are connected to current node
That is what for next_node in destinations defines as you can see destination is equivalent graph.edges(current_node) which means all the nodes connected to current node
weight is basically the the weight till that next_node if the path was passing through that current_node.
current_shortest_weight says the weight of the path from soure i.e. 1 till the destination i.e. next node

All the lines in between the loops automatically take in N complexity.

in the FOR LOOP everything is on N*N complexity

overall complexity of this code is O(N^2)