Printing Paths in Dijkstra’s Shortest Path Algorithm
Given a graph and a source vertex in the graph, find the shortest paths from the source to all vertices in the given graph.
We have discussed Dijkstra’s Shortest Path algorithm in the below posts.
- Dijkstra’s shortest path for adjacency matrix representation
- Dijkstra’s shortest path for adjacency list representation
The implementations discussed above only find shortest distances, but do not print paths. In this post-printing of paths is discussed.
Example:
Input: Consider below graph and source as 0,
Graph Used in the problem
OutputVertex Distance Path 0 -> 1 4 0 1 0 -> 2 12 0 1 2 0 -> 3 19 0 1 2 3 0 -> 4 21 0 7 6 5 4 0 -> 5 11 0 7 6 5 0 -> 6 9 0 7 6 0 -> 7 8 0 7 0 -> 8 14 0 1 2 8
The idea is to create a separate array parent[]. Value of parent[v] for a vertex v stores parent vertex of v in shortest path tree. The parent of the root (or source vertex) is -1. Whenever we find a shorter path through a vertex u, we make u as a parent of the current vertex.
Once we have the parent array constructed, we can print the path using the below recursive function.
void printPath(int parent[], int j) { // Base Case : If j is source if (parent[j]==-1) return; printPath(parent, parent[j]); printf("%d ", j); }
Below is the complete implementation:
C++
#include <bits/stdc++.h> using namespace std; // A Java program for Dijkstra's // single source shortest path // algorithm. The program is for // adjacency matrix representation // of the graph. int NO_PARENT = -1; // Function to print shortest path // from source to currentVertex // using parents array void printPath( int currentVertex, vector< int > parents) { // Base case : Source node has // been processed if (currentVertex == NO_PARENT) { return ; } printPath(parents[currentVertex], parents); cout << currentVertex << " " ; } // A utility function to print // the constructed distances // array and shortest paths void printSolution( int startVertex, vector< int > distances, vector< int > parents) { int nVertices = distances.size(); cout << "Vertex\t Distance\tPath" ; for ( int vertexIndex = 0; vertexIndex < nVertices; vertexIndex++) { if (vertexIndex != startVertex) { cout << "\n" << startVertex << " -> " ; cout << vertexIndex << " \t\t " ; cout << distances[vertexIndex] << "\t\t" ; printPath(vertexIndex, parents); } } } // Function that implements Dijkstra's // single source shortest path // algorithm for a graph represented // using adjacency matrix // representation void dijkstra(vector<vector< int > > adjacencyMatrix, int startVertex) { int nVertices = adjacencyMatrix[0].size(); // shortestDistances[i] will hold the // shortest distance from src to i vector< int > shortestDistances(nVertices); // added[i] will true if vertex i is // included / in shortest path tree // or shortest distance from src to // i is finalized vector< bool > added(nVertices); // Initialize all distances as // INFINITE and added[] as false for ( int vertexIndex = 0; vertexIndex < nVertices; vertexIndex++) { shortestDistances[vertexIndex] = INT_MAX; added[vertexIndex] = false ; } // Distance of source vertex from // itself is always 0 shortestDistances[startVertex] = 0; // Parent array to store shortest // path tree vector< int > parents(nVertices); // The starting vertex does not // have a parent parents[startVertex] = NO_PARENT; // Find shortest path for all // vertices for ( int i = 1; i < nVertices; i++) { // Pick the minimum distance vertex // from the set of vertices not yet // processed. nearestVertex is // always equal to startNode in // first iteration. int nearestVertex = -1; int shortestDistance = INT_MAX; for ( int vertexIndex = 0; vertexIndex < nVertices; vertexIndex++) { if (!added[vertexIndex] && shortestDistances[vertexIndex] < shortestDistance) { nearestVertex = vertexIndex; shortestDistance = shortestDistances[vertexIndex]; } } // Mark the picked vertex as // processed added[nearestVertex] = true ; // Update dist value of the // adjacent vertices of the // picked vertex. for ( int vertexIndex = 0; vertexIndex < nVertices; vertexIndex++) { int edgeDistance = adjacencyMatrix[nearestVertex] [vertexIndex]; if (edgeDistance > 0 && ((shortestDistance + edgeDistance) < shortestDistances[vertexIndex])) { parents[vertexIndex] = nearestVertex; shortestDistances[vertexIndex] = shortestDistance + edgeDistance; } } } printSolution(startVertex, shortestDistances, parents); } // Driver Code int main() { vector<vector< int > > adjacencyMatrix = { { 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, 0, 10, 0, 2, 0, 0 }, { 0, 0, 0, 14, 0, 2, 0, 1, 6 }, { 8, 11, 0, 0, 0, 0, 1, 0, 7 }, { 0, 0, 2, 0, 0, 0, 6, 7, 0 } }; dijkstra(adjacencyMatrix, 3); return 0; } |
Java
// A Java program for Dijkstra's // single source shortest path // algorithm. The program is for // adjacency matrix representation // of the graph. class DijkstrasAlgorithm { private static final int NO_PARENT = - 1 ; // Function that implements Dijkstra's // single source shortest path // algorithm for a graph represented // using adjacency matrix // representation private static void dijkstra( int [][] adjacencyMatrix, int startVertex) { int nVertices = adjacencyMatrix[ 0 ].length; // shortestDistances[i] will hold the // shortest distance from src to i int [] shortestDistances = new int [nVertices]; // added[i] will true if vertex i is // included / in shortest path tree // or shortest distance from src to // i is finalized boolean [] added = new boolean [nVertices]; // Initialize all distances as // INFINITE and added[] as false for ( int vertexIndex = 0 ; vertexIndex < nVertices; vertexIndex++) { shortestDistances[vertexIndex] = Integer.MAX_VALUE; added[vertexIndex] = false ; } // Distance of source vertex from // itself is always 0 shortestDistances[startVertex] = 0 ; // Parent array to store shortest // path tree int [] parents = new int [nVertices]; // The starting vertex does not // have a parent parents[startVertex] = NO_PARENT; // Find shortest path for all // vertices for ( int i = 1 ; i < nVertices; i++) { // Pick the minimum distance vertex // from the set of vertices not yet // processed. nearestVertex is // always equal to startNode in // first iteration. int nearestVertex = - 1 ; int shortestDistance = Integer.MAX_VALUE; for ( int vertexIndex = 0 ; vertexIndex < nVertices; vertexIndex++) { if (!added[vertexIndex] && shortestDistances[vertexIndex] < shortestDistance) { nearestVertex = vertexIndex; shortestDistance = shortestDistances[vertexIndex]; } } // Mark the picked vertex as // processed added[nearestVertex] = true ; // Update dist value of the // adjacent vertices of the // picked vertex. for ( int vertexIndex = 0 ; vertexIndex < nVertices; vertexIndex++) { int edgeDistance = adjacencyMatrix[nearestVertex][vertexIndex]; if (edgeDistance > 0 && ((shortestDistance + edgeDistance) < shortestDistances[vertexIndex])) { parents[vertexIndex] = nearestVertex; shortestDistances[vertexIndex] = shortestDistance + edgeDistance; } } } printSolution(startVertex, shortestDistances, parents); } // A utility function to print // the constructed distances // array and shortest paths private static void printSolution( int startVertex, int [] distances, int [] parents) { int nVertices = distances.length; System.out.print( "Vertex\t Distance\tPath" ); for ( int vertexIndex = 0 ; vertexIndex < nVertices; vertexIndex++) { if (vertexIndex != startVertex) { System.out.print( "\n" + startVertex + " -> " ); System.out.print(vertexIndex + " \t\t " ); System.out.print(distances[vertexIndex] + "\t\t" ); printPath(vertexIndex, parents); } } } // Function to print shortest path // from source to currentVertex // using parents array private static void printPath( int currentVertex, int [] parents) { // Base case : Source node has // been processed if (currentVertex == NO_PARENT) { return ; } printPath(parents[currentVertex], parents); System.out.print(currentVertex + " " ); } // Driver Code public static void main(String[] args) { int [][] adjacencyMatrix = { { 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 , 0 , 10 , 0 , 2 , 0 , 0 }, { 0 , 0 , 0 , 14 , 0 , 2 , 0 , 1 , 6 }, { 8 , 11 , 0 , 0 , 0 , 0 , 1 , 0 , 7 }, { 0 , 0 , 2 , 0 , 0 , 0 , 6 , 7 , 0 } }; dijkstra(adjacencyMatrix, 0 ); } } // This code is contributed by Harikrishnan Rajan |
C#
// C# program for Dijkstra's // single source shortest path // algorithm. The program is for // adjacency matrix representation // of the graph. using System; public class DijkstrasAlgorithm { private static readonly int NO_PARENT = -1; // Function that implements Dijkstra's // single source shortest path // algorithm for a graph represented // using adjacency matrix // representation private static void dijkstra( int [,] adjacencyMatrix, int startVertex) { int nVertices = adjacencyMatrix.GetLength(0); // shortestDistances[i] will hold the // shortest distance from src to i int [] shortestDistances = new int [nVertices]; // added[i] will true if vertex i is // included / in shortest path tree // or shortest distance from src to // i is finalized bool [] added = new bool [nVertices]; // Initialize all distances as // INFINITE and added[] as false for ( int vertexIndex = 0; vertexIndex < nVertices; vertexIndex++) { shortestDistances[vertexIndex] = int .MaxValue; added[vertexIndex] = false ; } // Distance of source vertex from // itself is always 0 shortestDistances[startVertex] = 0; // Parent array to store shortest // path tree int [] parents = new int [nVertices]; // The starting vertex does not // have a parent parents[startVertex] = NO_PARENT; // Find shortest path for all // vertices for ( int i = 1; i < nVertices; i++) { // Pick the minimum distance vertex // from the set of vertices not yet // processed. nearestVertex is // always equal to startNode in // first iteration. int nearestVertex = -1; int shortestDistance = int .MaxValue; for ( int vertexIndex = 0; vertexIndex < nVertices; vertexIndex++) { if (!added[vertexIndex] && shortestDistances[vertexIndex] < shortestDistance) { nearestVertex = vertexIndex; shortestDistance = shortestDistances[vertexIndex]; } } // Mark the picked vertex as // processed added[nearestVertex] = true ; // Update dist value of the // adjacent vertices of the // picked vertex. for ( int vertexIndex = 0; vertexIndex < nVertices; vertexIndex++) { int edgeDistance = adjacencyMatrix[nearestVertex,vertexIndex]; if (edgeDistance > 0 && ((shortestDistance + edgeDistance) < shortestDistances[vertexIndex])) { parents[vertexIndex] = nearestVertex; shortestDistances[vertexIndex] = shortestDistance + edgeDistance; } } } printSolution(startVertex, shortestDistances, parents); } // A utility function to print // the constructed distances // array and shortest paths private static void printSolution( int startVertex, int [] distances, int [] parents) { int nVertices = distances.Length; Console.Write( "Vertex\t Distance\tPath" ); for ( int vertexIndex = 0; vertexIndex < nVertices; vertexIndex++) { if (vertexIndex != startVertex) { Console.Write( "\n" + startVertex + " -> " ); Console.Write(vertexIndex + " \t\t " ); Console.Write(distances[vertexIndex] + "\t\t" ); printPath(vertexIndex, parents); } } } // Function to print shortest path // from source to currentVertex // using parents array private static void printPath( int currentVertex, int [] parents) { // Base case : Source node has // been processed if (currentVertex == NO_PARENT) { return ; } printPath(parents[currentVertex], parents); Console.Write(currentVertex + " " ); } // Driver Code public static void Main(String[] args) { int [,] adjacencyMatrix = { { 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, 0, 10, 0, 2, 0, 0 }, { 0, 0, 0, 14, 0, 2, 0, 1, 6 }, { 8, 11, 0, 0, 0, 0, 1, 0, 7 }, { 0, 0, 2, 0, 0, 0, 6, 7, 0 } }; dijkstra(adjacencyMatrix, 0); } } // This code has been contributed by 29AjayKumar |
Vertex Distance Path 0 -> 1 4 0 1 0 -> 2 12 0 1 2 0 -> 3 19 0 1 2 3 0 -> 4 21 0 7 6 5 4 0 -> 5 11 0 7 6 5 0 -> 6 9 0 7 6 0 -> 7 8 0 7 0 -> 8 14 0 1 2 8
This article is contributed by Aditya Goel. Please write comments if you find anything incorrect, or if you want to share more information about the topic discussed above
Please Login to comment...