Dijkstra's Algorithm vs A* Algorithm in Python

What are the main differences between Dijkstra's Algorithm and A* Algorithm in Python?

Dijkstra's Algorithm finds the shortest path from a source to all nodes, while A* uses heuristics to optimize pathfinding.

Can you provide a simple Python implementation of both algorithms?

Sure! Here's a basic implementation of Dijkstra's Algorithm:

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

And for A*:

def a_star(graph, start, goal, heuristic):
    open_set = {start}
    came_from = {}
    g_score = {node: float('infinity') for node in graph}
    g_score[start] = 0
    f_score = {node: float('infinity') for node in graph}
    f_score[start] = heuristic[start]

    while open_set:
        current = min(open_set, key=lambda node: f_score[node])

        if current == goal:
            return reconstruct_path(came_from, current)

        open_set.remove(current)

        for neighbor, weight in graph[current].items():
            tentative_g_score = g_score[current] + weight

            if tentative_g_score < g_score[neighbor]:
                came_from[neighbor] = current
                g_score[neighbor] = tentative_g_score
                f_score[neighbor] = g_score[neighbor] + heuristic[neighbor]
                open_set.add(neighbor)

    return False

Let me know if you need further explanations!

What are the use cases for each algorithm?

Dijkstra's Algorithm is great for finding the shortest path in weighted graphs without negative weights, like GPS navigation. A* is often used in game development for pathfinding, as it can efficiently find paths using heuristics.