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

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.