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.

Can you show me an example of using a priority queue?

Sure! You can use the heapq module in Python. Here's a simple example:

import heapq

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

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

        if current_distance > distances[current_vertex]:
            continue

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

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

    return distances

What is the time complexity of this optimized version?

The time complexity of Dijkstra's algorithm using a priority queue is O((V + E) log V), where V is the number of vertices and E is the number of edges.

Are there any other algorithms I should consider for shortest paths?

Yes, you might also consider A* algorithm for pathfinding, especially if you have heuristic information about the distances.