Dijkstra's Algorithm in Python

Find the shortest routes between a source vertex and each vertex in the provided graph, given the graph and the source vertex.

Dijkstra's method and Prim's approach for the minimal spanning tree are extremely similar. We create an SPT (shortest path tree) with a specified source as the root, similar to Prim's MST. We keep two sets; one set has vertices that are part of the shortest-path tree, while the other set contains vertices that aren't yet a part of the tree. We look for a vertex in the other set (the set still needs to be included) with a minimal distance from the source at each stage of the method.

The exact steps taken by Dijkstra's method to determine the shortest route between a single source vertex and every other vertex in the supplied graph are listed below.

Algorithm:

Create a set called sptSet (shortest path tree set) using algorithm 1 to keep track of the vertices that are part of the shortest path tree, whose minimal distance from the source is determined and determined. This collection is initially empty.
Give each vertex in the input network a distance value. Set all distance values to INFINITE at the beginning. Set the source vertex's distance value to 0 to ensure it is chosen first.
Even if sptSet is missing certain vertices:
- Choose a vertex u with a minimum distance value not present in the sptSet.
- Add you to the sptSet.
- Update the distance between each of its neighboring vertices. Iterate over all nearby vertices to update the distance values. If the weight of the edge u-v plus the distance value of u (from source) for each neighboring vertex v is less than the distance value of v, then the distance value of v should be updated.

Program Code:

# Programme in Python for Dijkstra's single
#shortest route algorithm from the source. The initiative is
# for the graph's adjacency matrix representation.
class Graph(): 
    def __init__(self, vertices):
        self.V = vertices
        self.graph = [[0 for column in range(vertices)]
                      for row in range(vertices)]
    def printSolution(self, dist):
        print("Vertex \t Distance from Source")
        for node in range(self.V):
            print(node, "\t\t", dist[node])
    # A practical method for locating the vertices
    # Minimum distance between this point and the collection of vertices
   # not yet listed in the shortest route tree.
    def minDistance(self, dist, sptSet): 
        # Initialise the following node's minimum distance
        min = 1e7
        # Try not to look for the closest vertex in the list of the shortest paths.
        for v in range(self.V):
            if dist[v] < min and sptSet[v] == False:
                min = dist[v]
                min_index = v
        return min_index
    # Implementation of Dijkstra's single source
    # representation of the shortest route algorithm for a graph
    #Adjacency matrix representation is used in
    def dijkstra(self, src):
        dist = [1e7] * self.V
        dist[src] = 0
        sptSet = [False] * self.V 
        for cout in range(self.V):
            # Choosing the vertex with the shortest distance
           # the collection of unprocessed vertices In the initial iteration,
           # u is always equal to src.
            u = self.minDistance(dist, sptSet)
            # Embedding the smallest separation vertex in the
            #number shortest route tree
            sptSet[u] = True
            # Update the distance between the nearby vertices.
            # solely if the current
            # greater than the new distance, and
            # The vertex is absent from the tree of the shortest paths.
            for v in range(self.V):
                if (self.graph[u][v] > 0 and
                   sptSet[v] == False and
                   dist[v] > dist[u] + self.graph[u][v]):
                    dist[v] = dist[u] + self.graph[u][v]
        self.printSolution(dist)
# Driver program
g = Graph(9)
g.graph = [[0, 4, 0, 0, 0, 0, 0, 8, 0],
           [4, 0, 8, 0, 0, 0, 0, 11, 0],
           [0, 8, 0, 7, 0, 4, 0, 0, 2],
           [0, 0, 7, 0, 9, 14, 0, 0, 0],
           [0, 0, 0, 9, 0, 10, 0, 0, 0],
           [0, 0, 4, 14, 10, 0, 2, 0, 0],
           [0, 0, 0, 0, 0, 2, 0, 1, 6],
           [8, 11, 0, 0, 0, 0, 1, 0, 7],
           [0, 0, 2, 0, 0, 0, 6, 7, 0]
           ]
g.dijkstra(0)

Output:

Vertex      Distance from Source
0          0
1          4
2          12
3          19
4          21
5          11
6          9
7          8
8          14

Time Complexity: The Dijkstra algorithm has an O(V2) time complexity. This is due to the algorithm's using two nested loops to iteratively search the network for the shortest route connecting all nodes to the source node.
Space Complexity: Dijkstra's algorithm has an O(V) space complexity, where V is the number of vertices in the graph. This is so that the method may record the distances between the source node and every other node in an array of size V.

Next TopicFingerprint-matching-algorithm-in-python

← prev next →