Open In App
Related Articles

# 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.

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 ``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 > 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 > 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`

## 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``)`

## 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);`

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)```