You are currently viewing What is Dijkstra Algorithm?

What is Dijkstra Algorithm?

The Dijkstra Algorithm is a graph search algorithm that solves the single-source shortest path problem for a graph with non-negative edge weights. The algorithm is named after its discoverer, Dutch computer scientist Edsger W. Dijkstra.

Features of dijkstra algorithm

  • It is a greedy algorithm that finds the shortest path from a starting node to all other nodes in a graph.
  • It uses a priority queue to keep track of the nodes that have been visited and the shortest distance to them.
  • It is not guaranteed to find the shortest path if there are multiple shortest paths.
  • It guarantees to find the shortest path from a given starting node to all other nodes in the graph, given that the graph does not contain any negative weight cycles.

Examples of dijkstra algorithm

1. Find the shortest path from node A to node B in a graph.

def dijkstra(graph, A, B):
    # create a set of visited nodes
    visited = set()
    # create a set of nodes to be visited
    unvisited = set(graph.keys())
    # create a dictionary of distances
    distance = {}
    # create a dictionary of predecessors
    predecessor = {}
    # assign the distance from A to A to be 0
    distance[A] = 0
    # assign the predecessor of A to be None
    predecessor[A] = None
    # while there are unvisited nodes
    while unvisited:
        # find the node with the smallest distance in the set of unvisited nodes
        current = min(unvisited, key=lambda k: distance[k])
        # remove the node from the set of unvisited nodes
        unvisited.remove(current)
        # if the distance of the current node is infinity, there is no path to the end node
        if distance[current] == float('inf'):
            break
        # for each neighbor of the current node
        for neighbor in graph[current]:
            # if the neighbor is not visited
            if neighbor not in visited:
  # if the distance to the neighbor is greater than the distance to the current node plus the edge weight
                if distance[neighbor] > distance[current] + graph[current][neighbor]:
                    # update the distance to the neighbor
                    distance[neighbor] = distance[current] + graph[current][neighbor]
                    # update the predecessor of the neighbor
                    predecessor[neighbor] = current
        # add the current node to the set of visited nodes
        visited.add(current)
    # if the distance to the end node is infinity, there is no path to the end node
    if distance[B] == float('inf'):
        return None
    # create a list of nodes that are on the shortest path from the start node to the end node
    path = []
    # set the current node to be the end node
    current = B
    # while the current node has a predecessor
    while current:
        # add the current node to the list of nodes
        path.append(current)

2. Find the shortest path from node A to all other nodes in a graph.

def dijkstra(graph, start):
    # initialize the distance to start node to 0
    distance = {start: 0}
    # initialize the set of visited nodes to empty
    visited = set()
    # initialize the set of unvisited nodes to all nodes in the graph
    unvisited = set(graph.keys())
    # while there are unvisited nodes
    while unvisited:
        # find the node with the smallest distance in the set of unvisited nodes
        current = min(unvisited, key=lambda x: distance[x])
        # add the node to the set of visited nodes
        visited.add(current)
        # remove the node from the set of unvisited nodes
        unvisited.remove(current)
        # for each node in the current node's adjacency list
        for neighbor in graph[current]:
            # if the distance to the neighbor is infinite
            if neighbor not in distance:
            # set the distance to the neighbor to the distance to the current node plus the edge weight
                distance[neighbor] = distance[current] + graph[current][neighbor]
    # return the distance dictionary
    return distance

3. Find the shortest path from node A to node B in a weighted graph.

def dijkstra(graph, start, goal):
    # keep track of all the nodes
    nodes = [start]
    # keep track of all the paths
    paths = {start: [start]}
    # keep track of all the shortest paths
    shortest_paths = {start: 0}
    # keep track of all the shortest paths
    visited = set()
    # keep looping until all the nodes have been visited
    while nodes:
        # sort the nodes
        nodes.sort(key=lambda x: shortest_paths[x])
        # get the first node
        current_node = nodes.pop(0)
        # check if the current node is the goal
        if current_node == goal:
            return paths[current_node]
        # check if the current node has already been visited
        if current_node in visited:
            continue
        # get the neighbors of the current node
        neighbors = graph[current_node]
        # loop over the neighbors
        for neighbor in neighbors:
            # get the edge weight
            edge_weight = neighbors[neighbor]
            # get the total distance from the start node to the neighbor
            total_distance = shortest_paths[current_node] + edge_weight
            # check if the neighbor has already been visited
            if neighbor in visited:
                continue
            # check if the current neighbor is already in the shortest paths
            if neighbor not in shortest_paths or total_distance < shortest_paths[neighbor]:
                # add the neighbor to the shortest paths
                shortest_paths[neighbor] = total_distance
                # add the neighbor to the paths
                paths[neighbor] = paths[current_node] + [neighbor]
        # mark the current node as visited
        visited.add(current_node)
    # return an empty list if there is no path
    return []

4. Find the shortest path from node A to all other nodes in a weighted graph.

def dijkstra(graph, start):
    # create a set of nodes not yet evaluated
    unvisited_nodes = set(graph.nodes)
    # create a dictionary to hold the shortest path to each node
    shortest_paths = {node: float('inf') for node in graph.nodes}
    # set the distance from the start node to itself to 0
    shortest_paths[start] = 0
    # while there are nodes to evaluate
    while unvisited_nodes:
        # find the unvisited node with the smallest distance
        current_node, current_distance = sorted(
            [(node, shortest_paths[node]) for node in unvisited_nodes],
            key=lambda x: x[1])[0]
        # remove the current node from the unvisited nodes
        unvisited_nodes.remove(current_node)
        # for each neighbour of the current node
        for neighbour, distance in graph.edges[current_node].items():
            # if the distance to the neighbour is lower than the current
            # distance
            if distance + current_distance < shortest_paths[neighbour]:
                # update the distance to the neighbour
                shortest_paths[neighbour] = distance + current_distance
    return shortest_paths

Conclusion

You could use these codes explaining dijkstra algorithm.

Leave a Reply