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 <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
- Shortest path with exactly k edges in a directed and weighted graph | Set 2
- Convert the undirected graph into directed graph such that there is no path of length greater than 1
- Detect a negative cycle in a Graph using Shortest Path Faster Algorithm
- Number of shortest paths in an unweighted and directed graph
- Find if there is a path between two vertices in a directed graph
- Longest Path in a Directed Acyclic Graph
- Longest Path in a Directed Acyclic Graph | Set 2
- Find if there is a path between two vertices in a directed graph | Set 2
- Path with minimum XOR sum of edges in a directed graph
- Longest path in a directed Acyclic graph | Dynamic Programming
- Minimum Cost Path in a directed graph via given set of intermediate nodes
- Minimum Cost of Simple Path between two nodes in a Directed and Weighted Graph
- Hierholzer's Algorithm for directed graph
- Why Prim’s and Kruskal's MST algorithm fails for Directed Graph?
- Convert undirected connected graph to strongly connected directed graph
- Shortest path from source to destination such that edge weights along path are alternatively increasing and decreasing
- Dijkstra's shortest path algorithm | Greedy Algo-7
- Printing Paths in Dijkstra's Shortest Path Algorithm

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.

**Article Tags :**