# Number of shortest paths in an unweighted and directed graph

Given an unweighted directed graph, can be cyclic or acyclic. Print the number of shortest paths from a given vertex to each of the vertices. For example consider the below graph. There is one shortest path vertex 0 to vertex 0 (from each vertex there is a single shortest path to itself), one shortest path between vertex 0 to vertex 2 (0->2), and there are 4 different shortest paths from vertex 0 to vertex 6:

1. 0->1->3->4->6

2. 0->1->3->5->6

3. 0->2->3->4->6

4. 0->2->3->5->6

The idea is to use BFS. We use two arrays called dist[] and paths[], dist[] represents the shorest distances from source vertex, and paths[] represents the number of different shortest paths from the source vertex to each of the vertices. Initially all the elements in dist[] are infinity except source vertex which is equal to 0, since the distance to source vertex from itself is 0, and all the elements in paths[] are 0 except source vertex which is equal to 1, since each vertex has a single shortest path to itself. after that, we start traversing the graph using BFS manner.

Then, for every neighbor Y of each vertex X do:

1) if dist[Y] > dist[X]+1 decrease the dist[Y] to dist[X] +1 and assign the number of paths of vertex X to number of paths of vertex Y.

2) else if dist[Y] = dist[X] + 1, then add the number of paths of vertex X to the number of paths of vertex Y.

For example:

Let’s take a look at the below graph. The source vertex is 0. Suppose we traverse on vertex 2, we check all its neighbors, which is only 3.since vertex 3 was already visited when we were traversed vertex 1, dist[3] = 2 and paths[3] = 1. The second condition is true, so it means that addtional shortest paths have been found, so we add to the number of paths of vertex 3, the number of paths of vertex 2.

The equal condition happens when we traverse on vertex 5:

`// CPP program to count number of shortest ` `// paths from a given source to every other ` `// vertex using BFS. ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Traverses graph in BFS manner. It fills ` `// dist[] and paths[] ` `void` `BFS(vector<` `int` `> adj[], ` `int` `src, ` `int` `dist[], ` ` ` `int` `paths[], ` `int` `n) ` `{ ` ` ` `bool` `visited[n]; ` ` ` `for` `(` `int` `i = 0; i < n; i++) ` ` ` `visited[i] = ` `false` `; ` ` ` `dist[src] = 0; ` ` ` `paths[src] = 1; ` ` ` ` ` `queue <` `int` `> q; ` ` ` `q.push(src); ` ` ` `visited[src] = ` `true` `; ` ` ` `while` `(!q.empty()) ` ` ` `{ ` ` ` `int` `curr = q.front(); ` ` ` `q.pop(); ` ` ` ` ` `// For all neighbors of current vertex do: ` ` ` `for` `(` `auto` `x : adj[curr]) ` ` ` `{ ` ` ` `// if the current vertex is not yet ` ` ` `// visited, then push it to the queue. ` ` ` `if` `(visited[x] == ` `false` `) ` ` ` `{ ` ` ` `q.push(x); ` ` ` `visited[x] = ` `true` `; ` ` ` `} ` ` ` ` ` `// check if there is a better path. ` ` ` `if` `(dist[x] > dist[curr] + 1) ` ` ` `{ ` ` ` `dist[x] = dist[curr] + 1; ` ` ` `paths[x] = paths[curr]; ` ` ` `} ` ` ` ` ` `// additional shortest paths found ` ` ` `else` `if` `(dist[x] == dist[curr] + 1) ` ` ` `paths[x] += paths[curr]; ` ` ` `} ` ` ` `} ` `} ` ` ` `// function to find number of different ` `// shortest paths form given vertex s. ` `// n is number of vertices. ` `void` `findShortestPaths(vector<` `int` `> adj[], ` ` ` `int` `s, ` `int` `n) ` `{ ` ` ` `int` `dist[n], paths[n]; ` ` ` `for` `(` `int` `i = 0; i < n; i++) ` ` ` `dist[i] = INT_MAX; ` ` ` `for` `(` `int` `i = 0; i < n; i++) ` ` ` `paths[i] = 0; ` ` ` `BFS(adj, s, dist, paths, n); ` ` ` `cout << ` `"Numbers of shortest Paths are: "` `; ` ` ` `for` `(` `int` `i = 0; i < n; i++) ` ` ` `cout << paths[i] << ` `" "` `; ` `} ` ` ` `// A utility function to add an edge in a ` `// directed graph. ` `void` `addEdge(vector<` `int` `> adj[], ` `int` `u, ` `int` `v) ` `{ ` ` ` `adj[u].push_back(v); ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` `int` `n = 7; ` `// Number of vertices ` ` ` `vector <` `int` `> adj[n]; ` ` ` `addEdge(adj, 0, 1); ` ` ` `addEdge(adj, 0, 2); ` ` ` `addEdge(adj, 1, 2); ` ` ` `addEdge(adj, 1, 3); ` ` ` `addEdge(adj, 2, 3); ` ` ` `addEdge(adj, 3, 4); ` ` ` `addEdge(adj, 3, 5); ` ` ` `addEdge(adj, 4, 6); ` ` ` `addEdge(adj, 5, 6); ` ` ` `findShortestPaths(adj, 0, 7); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

**Output:**

Numbers of shortest Paths are: 1 1 1 2 2 2 4

**Time Complexity : O(V + E)**

## Recommended Posts:

- Shortest path in an unweighted graph
- Multi Source Shortest Path in Unweighted Graph
- Shortest Path in Directed Acyclic Graph
- Shortest path with exactly k edges in a directed and weighted graph
- Graph implementation using STL for competitive programming | Set 1 (DFS of Unweighted and Undirected)
- Johnson's algorithm for All-pairs shortest paths
- Johnson’s algorithm for All-pairs shortest paths | Implementation
- Printing Paths in Dijkstra's Shortest Path Algorithm
- Hierholzer's Algorithm for directed graph
- Detect Cycle in a Directed Graph using BFS
- Detect Cycle in a Directed Graph
- Clone a Directed Acyclic Graph
- Euler Circuit in a Directed Graph
- Find if there is a path between two vertices in a directed graph
- Longest Path in a Directed Acyclic Graph | Set 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.