# 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 <bits/stdc++.h> ` `#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<pair<` `int` `, ` `int` `> > 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<Node*> 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<Node*> 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[0]->add_child(1, 1); ` ` ` `v[0]->add_child(2, 4); ` ` ` `v[1]->add_child(2, 2); ` ` ` `v[1]->add_child(3, 6); ` ` ` `v[2]->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; ` `} ` |

*chevron_right*

*filter_none*

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

## Recommended Posts:

- Shortest Path in Directed Acyclic Graph
- Shortest path with exactly k edges in a directed and weighted graph | Set 2
- Shortest path with exactly k edges in a directed and weighted graph
- Convert the undirected graph into directed graph such that there is no path of length greater than 1
- Number of shortest paths in an unweighted and directed graph
- Path with minimum XOR sum of edges in a directed graph
- Longest Path in a Directed Acyclic Graph
- Find if there is a path between two vertices in a directed graph
- Longest Path in a Directed Acyclic Graph | Set 2
- Hierholzer's Algorithm for directed graph
- Longest path in a directed Acyclic graph | Dynamic Programming
- Minimum Cost of Simple Path between two nodes in a Directed and Weighted Graph
- Why Prim’s and Kruskal's MST algorithm fails for Directed Graph?
- Multistage Graph (Shortest Path)
- Shortest path in a complement graph
- Shortest path in an unweighted graph
- 0-1 BFS (Shortest Path in a Binary Weight Graph)
- Dijkstra’s shortest path algorithm using set in STL
- Shortest Path Faster Algorithm
- Shortest Path in a weighted Graph where weight of an edge is 1 or 2

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.