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,
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:
#include <bits/stdc++.h> using namespace std;
// A C++ 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;
} |
// 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 |
import sys
NO_PARENT = - 1
def dijkstra(adjacency_matrix, start_vertex):
n_vertices = len (adjacency_matrix[ 0 ])
# shortest_distances[i] will hold the
# shortest distance from start_vertex to i
shortest_distances = [sys.maxsize] * n_vertices
# added[i] will true if vertex i is
# included in shortest path tree
# or shortest distance from start_vertex to
# i is finalized
added = [ False ] * n_vertices
# Initialize all distances as
# INFINITE and added[] as false
for vertex_index in range (n_vertices):
shortest_distances[vertex_index] = sys.maxsize
added[vertex_index] = False
# Distance of source vertex from
# itself is always 0
shortest_distances[start_vertex] = 0
# Parent array to store shortest
# path tree
parents = [ - 1 ] * n_vertices
# The starting vertex does not
# have a parent
parents[start_vertex] = NO_PARENT
# Find shortest path for all
# vertices
for i in range ( 1 , n_vertices):
# Pick the minimum distance vertex
# from the set of vertices not yet
# processed. nearest_vertex is
# always equal to start_vertex in
# first iteration.
nearest_vertex = - 1
shortest_distance = sys.maxsize
for vertex_index in range (n_vertices):
if not added[vertex_index] and shortest_distances[vertex_index] < shortest_distance:
nearest_vertex = vertex_index
shortest_distance = shortest_distances[vertex_index]
# Mark the picked vertex as
# processed
added[nearest_vertex] = True
# Update dist value of the
# adjacent vertices of the
# picked vertex.
for vertex_index in range (n_vertices):
edge_distance = adjacency_matrix[nearest_vertex][vertex_index]
if edge_distance > 0 and shortest_distance + edge_distance < shortest_distances[vertex_index]:
parents[vertex_index] = nearest_vertex
shortest_distances[vertex_index] = shortest_distance + edge_distance
print_solution(start_vertex, shortest_distances, parents)
# A utility function to print # the constructed distances # array and shortest paths def print_solution(start_vertex, distances, parents):
n_vertices = len (distances)
print ( "Vertex\t Distance\tPath" )
for vertex_index in range (n_vertices):
if vertex_index ! = start_vertex:
print ( "\n" , start_vertex, "->" , vertex_index, "\t\t" , distances[vertex_index], "\t\t" , end = "")
print_path(vertex_index, parents)
# Function to print shortest path # from source to current_vertex # using parents array def print_path(current_vertex, parents):
# Base case : Source node has
# been processed
if current_vertex = = NO_PARENT:
return
print_path(parents[current_vertex], parents)
print (current_vertex, end = " " )
# Driver code if __name__ = = '__main__' :
adjacency_matrix = [[ 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 ]]
dijkstra(adjacency_matrix, 0 )
|
// 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 |
const NO_PARENT = -1; function dijkstra(adjacencyMatrix, startVertex) {
const nVertices = adjacencyMatrix[0].length;
// shortestDistances[i] will hold the shortest distance from startVertex to i
const shortestDistances = new Array(nVertices).fill(Number.MAX_SAFE_INTEGER);
// added[i] will true if vertex i is included in shortest path tree
// or shortest distance from startVertex to i is finalized
const added = new Array(nVertices).fill( false );
// Initialize all distances as infinite and added[] as false
for (let vertexIndex = 0; vertexIndex < nVertices; vertexIndex++) {
shortestDistances[vertexIndex] = Number.MAX_SAFE_INTEGER;
added[vertexIndex] = false ;
}
// Distance of source vertex from itself is always 0
shortestDistances[startVertex] = 0;
// Parent array to store shortest path tree
const parents = new Array(nVertices).fill(NO_PARENT);
// The starting vertex does not have a parent
parents[startVertex] = NO_PARENT;
// Find shortest path for all vertices
for (let i = 1; i < nVertices; i++) {
// Pick the minimum distance vertex from the set of vertices not yet processed.
// nearestVertex is always equal to startVertex in first iteration.
let nearestVertex = -1;
let shortestDistance = Number.MAX_SAFE_INTEGER;
for (let 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 (let vertexIndex = 0; vertexIndex < nVertices; vertexIndex++) {
const 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 function printSolution(startVertex, distances, parents) {
const nVertices = distances.length;
console.log( "Vertex\t Distance\tPath" );
for (let vertexIndex = 0; vertexIndex < nVertices; vertexIndex++) {
if (vertexIndex !== startVertex) {
process.stdout.write(`\n ${startVertex} -> ${vertexIndex}\t\t ${distances[vertexIndex]}\t\t`);
printPath(vertexIndex, parents);
}
}
} // Function to print shortest path from source to currentVertex using parents array function printPath(currentVertex, parents) {
// Base case: Source node has been processed
if (currentVertex === NO_PARENT) {
return ;
}
printPath(parents[currentVertex], parents);
process.stdout.write(`${currentVertex} `);
} // Driver code const 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, 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]
]; dijkstra(adjacencyMatrix, 0); |
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
Time Complexity:- O(V^2)
Space Complexity:- O(V^2)