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.
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 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;
}
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 ${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)
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4