# Shortest path in a directed graph by Dijkstra’s algorithm

Given a directed graph and a source vertex in the graph, the task is to find the shortest distance and path from source to target vertex in the given graph where edges are weighted (non-negative) and directed from parent vertex to source vertices.

Approach:

• Mark all vertices unvisited. Create a set of all unvisited vertices.
• Assign zero distance value to source vertex and infinity distance value to all other vertices.
• Set the source vertex as current vertex
• For current vertex, consider all of its unvisited children and calculate their tentative distances through the current. (distance of current + weight of the corresponding edge) Compare the newly calculated distance to the current assigned value (can be infinity for some vertices) and assign the smaller one.
• After considering all the unvisited children of the current vertex, mark the current as visited and remove it from the unvisited set.
• Similarly, continue for all the vertex until all the nodes are visited.

Below is the implementation of the above approach:

## C++

 `// C++ implementation to find the ` `// shortest path in a directed ` `// graph from source vertex to ` `// the destination vertex ` ` `  `#include ` `#define infi 1000000000 ` `using` `namespace` `std; ` ` `  `// Class of the node ` `class` `Node { ` `public``: ` `    ``int` `vertexNumber; ` ` `  `    ``// Adjacency list that shows the ` `    ``// vertexNumber of child vertex ` `    ``// and the weight of the edge ` `    ``vector > children; ` `    ``Node(``int` `vertexNumber) ` `    ``{ ` `        ``this``->vertexNumber = vertexNumber; ` `    ``} ` ` `  `    ``// Function to add the child for ` `    ``// the given node ` `    ``void` `add_child(``int` `vNumber, ``int` `length) ` `    ``{ ` `        ``pair<``int``, ``int``> p; ` `        ``p.first = vNumber; ` `        ``p.second = length; ` `        ``children.push_back(p); ` `    ``} ` `}; ` ` `  `// Function to find the distance of ` `// the node from the given source ` `// vertex to the destination vertex ` `vector<``int``> dijkstraDist( ` `    ``vector g, ` `    ``int` `s, vector<``int``>& path) ` `{ ` `    ``// Stores distance of each ` `    ``// vertex from source vertex ` `    ``vector<``int``> dist(g.size()); ` ` `  `    ``// Boolean array that shows ` `    ``// whether the vertex 'i' ` `    ``// is visited or not ` `    ``bool` `visited[g.size()]; ` `    ``for` `(``int` `i = 0; i < g.size(); i++) { ` `        ``visited[i] = ``false``; ` `        ``path[i] = -1; ` `        ``dist[i] = infi; ` `    ``} ` `    ``dist[s] = 0; ` `    ``path[s] = -1; ` `    ``int` `current = s; ` ` `  `    ``// Set of vertices that has ` `    ``// a parent (one or more) ` `    ``// marked as visited ` `    ``unordered_set<``int``> sett; ` `    ``while` `(``true``) { ` ` `  `        ``// Mark current as visited ` `        ``visited[current] = ``true``; ` `        ``for` `(``int` `i = 0; ` `             ``i < g[current]->children.size(); ` `             ``i++) { ` `            ``int` `v = g[current]->children[i].first; ` `            ``if` `(visited[v]) ` `                ``continue``; ` ` `  `            ``// Inserting into the ` `            ``// visited vertex ` `            ``sett.insert(v); ` `            ``int` `alt ` `                ``= dist[current] ` `                  ``+ g[current]->children[i].second; ` ` `  `            ``// Condition to check the distance ` `            ``// is correct and update it ` `            ``// if it is minimum from the previous ` `            ``// computed distance ` `            ``if` `(alt < dist[v]) { ` `                ``dist[v] = alt; ` `                ``path[v] = current; ` `            ``} ` `        ``} ` `        ``sett.erase(current); ` `        ``if` `(sett.empty()) ` `            ``break``; ` ` `  `        ``// The new current ` `        ``int` `minDist = infi; ` `        ``int` `index = 0; ` ` `  `        ``// Loop to update the distance ` `        ``// of the vertices of the graph ` `        ``for` `(``int` `a: sett) { ` `            ``if` `(dist[a] < minDist) { ` `                ``minDist = dist[a]; ` `                ``index = a; ` `            ``} ` `        ``} ` `        ``current = index; ` `    ``} ` `    ``return` `dist; ` `} ` ` `  `// Function to print the path ` `// from the source vertex to ` `// the destination vertex ` `void` `printPath(vector<``int``> path, ` `               ``int` `i, ``int` `s) ` `{ ` `    ``if` `(i != s) { ` ` `  `        ``// Condition to check if ` `        ``// there is no path between ` `        ``// the vertices ` `        ``if` `(path[i] == -1) { ` `            ``cout << ``"Path not found!!"``; ` `            ``return``; ` `        ``} ` `        ``printPath(path, path[i], s); ` `        ``cout << path[i] << ``" "``; ` `    ``} ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``vector v; ` `    ``int` `n = 4, s = 0, e = 5; ` ` `  `    ``// Loop to create the nodes ` `    ``for` `(``int` `i = 0; i < n; i++) { ` `        ``Node* a = ``new` `Node(i); ` `        ``v.push_back(a); ` `    ``} ` ` `  `    ``// Creating directed ` `    ``// weighted edges ` `    ``v->add_child(1, 1); ` `    ``v->add_child(2, 4); ` `    ``v->add_child(2, 2); ` `    ``v->add_child(3, 6); ` `    ``v->add_child(3, 3); ` ` `  `    ``vector<``int``> path(v.size()); ` `    ``vector<``int``> dist ` `        ``= dijkstraDist(v, s, path); ` ` `  `    ``// Loop to print the distance of ` `    ``// every node from source vertex ` `    ``for` `(``int` `i = 0; i < dist.size(); i++) { ` `        ``if` `(dist[i] == infi) { ` `            ``cout << i << ``" and "` `<< s ` `                 ``<< ``" are not connected"` `                 ``<< endl; ` `            ``continue``; ` `        ``} ` `        ``cout << ``"Distance of "` `<< i ` `             ``<< ``"th vertex from source vertex "` `             ``<< s << ``" is: "` `             ``<< dist[i] << endl; ` `    ``} ` `    ``return` `0; ` `} `

Output:

Distance of 0th vertex from source vertex 0 is: 0
Distance of 1th vertex from source vertex 0 is: 1
Distance of 2th vertex from source vertex 0 is: 3
Distance of 3th vertex from source vertex 0 is: 6

Time Complexity: Related articles: We have already discussed the shortest path in directed graph using Topological Sorting, in this article: Shortest path in Directed Acyclic graph My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.