Printing Paths in Dijkstra's Shortest Path Algorithm (original) (raw)
Last Updated : 23 Jul, 2025
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
Output
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
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 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 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 distances, vector 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 > 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 > 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
Python3
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#
// 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
` JavaScript ``
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 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mrow><mi>s</mi><mi>t</mi><mi>a</mi><mi>r</mi><mi>t</mi><mi>V</mi><mi>e</mi><mi>r</mi><mi>t</mi><mi>e</mi><mi>x</mi></mrow><mo>−</mo><mo>></mo></mrow><annotation encoding="application/x-tex">{startVertex} -> </annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.7667em;vertical-align:-0.0833em;"></span><span class="mord"><span class="mord mathnormal">s</span><span class="mord mathnormal">t</span><span class="mord mathnormal">a</span><span class="mord mathnormal" style="margin-right:0.02778em;">r</span><span class="mord mathnormal">t</span><span class="mord mathnormal" style="margin-right:0.22222em;">V</span><span class="mord mathnormal" style="margin-right:0.02778em;">er</span><span class="mord mathnormal">t</span><span class="mord mathnormal">e</span><span class="mord mathnormal">x</span></span><span class="mord">−</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">></span></span></span></span>{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);
``
Output
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)