How can I optimize Dijkstra's algorithm in Python?

How can I optimize Dijkstra's algorithm in Python?

You can optimize Dijkstra's algorithm by using a priority queue, such as a binary heap, to improve the efficiency of finding the shortest path.

What data structures should I use for the priority queue?

Using a heapq in Python is a great choice for implementing a priority queue. It allows for efficient insertion and extraction of the minimum element.

Are there any libraries that can help with this?

Yes, libraries like NetworkX provide built-in functions for Dijkstra's algorithm, which can save you time and effort.

Can you show me a code example?

Sure! Here's a simple implementation using heapq:

import heapq

def dijkstra(graph, start):
    queue = [(0, start)]
    distances = {node: float('infinity') for node in graph}
    distances[start] = 0

    while queue:
        current_distance, current_node = heapq.heappop(queue)

        if current_distance > distances[current_node]:
            continue

        for neighbor, weight in graph[current_node].items():
            distance = current_distance + weight

            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(queue, (distance, neighbor))

    return distances

What are the time and space complexities of this optimized version?

The time complexity is O((V + E) log V) where V is the number of vertices and E is the number of edges. The space complexity is O(V) for storing the distances.