# Printing Paths in Dijkstra’s Shortest Path Algorithm

• Difficulty Level : Medium
• Last Updated : 14 Sep, 2021

Given a graph and a source vertex in graph, find shortest paths from source to all vertices in the given graph.
We have discussed Dijkstra’s Shortest Path algorithm in below posts.

The implementations discussed above only find shortest distances, but do not print paths. In this post printing of paths is discussed.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

```For example, consider below graph and source as 0,

Output should be
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. Parent of root (or source vertex) is -1. Whenever we find shorter path through a vertex u, we make u as parent of current vertex.

Once we have parent array constructed, we can print path using 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++

 `// C program for Dijkstra's single  ` `// source shortest path algorithm. ` `// The program is for adjacency matrix ` `// representation of the graph. ` `#include ` `#include ` `  `  `// Number of vertices  ` `// in the graph ` `#define V 9 ` `  `  `// A utility function to find the  ` `// vertex with minimum distance ` `// value, from the set of vertices ` `// not yet included in shortest ` `// path tree ` `int` `minDistance(``int` `dist[],  ` `                ``bool` `sptSet[]) ` `{ ` `      `  `    ``// Initialize min value ` `    ``int` `min = INT_MAX, min_index; ` `  `  `    ``for` `(``int` `v = 0; v < V; v++) ` `        ``if` `(sptSet[v] == ``false` `&& ` `                   ``dist[v] <= min) ` `            ``min = dist[v], min_index = v; ` `  `  `    ``return` `min_index; ` `} ` `  `  `// Function to print shortest ` `// path from source to j ` `// using parent array ` `void` `printPath(``int` `parent[], ``int` `j) ` `{ ` `      `  `    ``// Base Case : If j is source ` `    ``if` `(parent[j] == - 1) ` `        ``return``; ` `  `  `    ``printPath(parent, parent[j]); ` `  `  `    ``printf``(``"%d "``, j); ` `} ` `  `  `// A utility function to print  ` `// the constructed distance ` `// array ` `int` `printSolution(``int` `dist[], ``int` `n,  ` `                      ``int` `parent[]) ` `{ ` `    ``int` `src = 0; ` `    ``printf``(``"Vertex\t Distance\tPath"``); ` `    ``for` `(``int` `i = 1; i < V; i++) ` `    ``{ ` `        ``printf``(``"\n%d -> %d \t\t %d\t\t%d "``, ` `                      ``src, i, dist[i], src); ` `        ``printPath(parent, i); ` `    ``} ` `} ` `  `  `// Function that implements Dijkstra's ` `// single source shortest path ` `// algorithm for a graph represented ` `// using adjacency matrix representation ` `void` `dijkstra(``int` `graph[V][V], ``int` `src) ` `{ ` `      `  `    ``// The output array. dist[i] ` `    ``// will hold the shortest ` `    ``// distance from src to i ` `    ``int` `dist[V];  ` `  `  `    ``// sptSet[i] will true if vertex ` `    ``// i is included / in shortest ` `    ``// path tree or shortest distance  ` `    ``// from src to i is finalized ` `    ``bool` `sptSet[V]; ` `  `  `    ``// Parent array to store ` `    ``// shortest path tree ` `    ``int` `parent[V]; ` `  `  `    ``// Initialize all distances as  ` `    ``// INFINITE and stpSet[] as false ` `    ``for` `(``int` `i = 0; i < V; i++) ` `    ``{ ` `        ``parent = -1; ` `        ``dist[i] = INT_MAX; ` `        ``sptSet[i] = ``false``; ` `    ``} ` `  `  `    ``// Distance of source vertex  ` `    ``// from itself is always 0 ` `    ``dist[src] = 0; ` `  `  `    ``// Find shortest path ` `    ``// for all vertices ` `    ``for` `(``int` `count = 0; count < V - 1; count++) ` `    ``{ ` `        ``// Pick the minimum distance ` `        ``// vertex from the set of ` `        ``// vertices not yet processed.  ` `        ``// u is always equal to src ` `        ``// in first iteration. ` `        ``int` `u = minDistance(dist, sptSet); ` `  `  `        ``// Mark the picked vertex  ` `        ``// as processed ` `        ``sptSet[u] = ``true``; ` `  `  `        ``// Update dist value of the  ` `        ``// adjacent vertices of the ` `        ``// picked vertex. ` `        ``for` `(``int` `v = 0; v < V; v++) ` `  `  `            ``// Update dist[v] only if is ` `            ``// not in sptSet, there is ` `            ``// an edge from u to v, and  ` `            ``// total weight of path from ` `            ``// src to v through u is smaller ` `            ``// than current value of ` `            ``// dist[v] ` `            ``if` `(!sptSet[v] && graph[u][v] && ` `                ``dist[u] + graph[u][v] < dist[v]) ` `            ``{ ` `                ``parent[v] = u; ` `                ``dist[v] = dist[u] + graph[u][v]; ` `            ``}  ` `    ``} ` `  `  `    ``// print the constructed ` `    ``// distance array ` `    ``printSolution(dist, V, parent); ` `} ` `  `  `// Driver Code ` `int` `main() ` `{ ` `    ``//  Let us create the example ` `    ``// graph discussed above ` `    ``int` `graph[V][V] = {{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(graph, 0); ` `    ``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`

## Python

 `# Python program for Dijkstra's ` `# single source shortest` `# path algorithm. The program` `# is for adjacency matrix` `# representation of the graph`   `from` `collections ``import` `defaultdict`   `#Class to represent a graph` `class` `Graph:`   `    ``# A utility function to find the ` `    ``# vertex with minimum dist value, from` `    ``# the set of vertices still in queue` `    ``def` `minDistance(``self``,dist,queue):` `        ``# Initialize min value and min_index as -1` `        ``minimum ``=` `float``(``"Inf"``)` `        ``min_index ``=` `-``1` `        `  `        ``# from the dist array,pick one which` `        ``# has min value and is till in queue` `        ``for` `i ``in` `range``(``len``(dist)):` `            ``if` `dist[i] < minimum ``and` `i ``in` `queue:` `                ``minimum ``=` `dist[i]` `                ``min_index ``=` `i` `        ``return` `min_index`     `    ``# Function to print shortest path` `    ``# from source to j` `    ``# using parent array` `    ``def` `printPath(``self``, parent, j):` `        `  `        ``#Base Case : If j is source` `        ``if` `parent[j] ``=``=` `-``1` `: ` `            ``print` `j,` `            ``return` `        ``self``.printPath(parent , parent[j])` `        ``print` `j,` `        `    `    ``# A utility function to print` `    ``# the constructed distance` `    ``# array` `    ``def` `printSolution(``self``, dist, parent):` `        ``src ``=` `0` `        ``print``(``"Vertex \t\tDistance from Source\tPath"``)` `        ``for` `i ``in` `range``(``1``, ``len``(dist)):` `            ``print``(``"\n%d --> %d \t\t%d \t\t\t\t\t"` `%` `(src, i, dist[i])),` `            ``self``.printPath(parent,i)`     `    ``'''Function that implements Dijkstra's single source shortest path` `    ``algorithm for a graph represented using adjacency matrix` `    ``representation'''` `    ``def` `dijkstra(``self``, graph, src):`   `        ``row ``=` `len``(graph)` `        ``col ``=` `len``(graph[``0``])`   `        ``# The output array. dist[i] will hold` `        ``# the shortest distance from src to i` `        ``# Initialize all distances as INFINITE ` `        ``dist ``=` `[``float``(``"Inf"``)] ``*` `row`   `        ``#Parent array to store ` `        ``# shortest path tree` `        ``parent ``=` `[``-``1``] ``*` `row`   `        ``# Distance of source vertex ` `        ``# from itself is always 0` `        ``dist[src] ``=` `0` `    `  `        ``# Add all vertices in queue` `        ``queue ``=` `[]` `        ``for` `i ``in` `range``(row):` `            ``queue.append(i)` `            `  `        ``#Find shortest path for all vertices` `        ``while` `queue:`   `            ``# Pick the minimum dist vertex ` `            ``# from the set of vertices` `            ``# still in queue` `            ``u ``=` `self``.minDistance(dist,queue) `   `            ``# remove min element     ` `            ``queue.remove(u)`   `            ``# Update dist value and parent ` `            ``# index of the adjacent vertices of` `            ``# the picked vertex. Consider only ` `            ``# those vertices which are still in` `            ``# queue` `            ``for` `i ``in` `range``(col):` `                ``'''Update dist[i] only if it is in queue, there is` `                ``an edge from u to i, and total weight of path from` `                ``src to i through u is smaller than current value of` `                ``dist[i]'''` `                ``if` `graph[u][i] ``and` `i ``in` `queue:` `                    ``if` `dist[u] ``+` `graph[u][i] < dist[i]:` `                        ``dist[i] ``=` `dist[u] ``+` `graph[u][i]` `                        ``parent[i] ``=` `u`     `        ``# print the constructed distance array` `        ``self``.printSolution(dist,parent)`   `g``=` `Graph()`   `graph ``=` `[[``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``]` `        ``]`   `# Print the solution` `g.dijkstra(graph,``0``)`     `# This code is contributed by Neelam Yadav`

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

 ``

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