Skip to content
Related Articles
Finding the path from one vertex to rest using BFS
• Last Updated : 02 Jun, 2021

Given an adjacency list representation of a directed graph, the task is to find the path from source to every other node in the graph using BFS.
Examples:

`Input:` ```Output:
0 <- 2
1 <- 0 <- 2
2
3 <- 1 <- 0 <- 2
4 <- 5 <- 2
5 <- 2
6 <- 2```

Approach: In the images shown below:

• que[] array stores the vertices reached and we will enqueue a vertex only if it has not been visited and dequeue it once all its child node have been considered.
• In order to distinguish whether the node has been visited or not we will put 1 in visited[] array at the respective index to signify it has been visited and if at given index 0 is present it will signify that it has not been visited.
• Parent array is to store the parent node of each vertex. For ex. In case of 0 connected to 2, 2 will be the parent node of 0 and we will put 2 at the index 0 in the parent array.        Below is the implementation of the above approach:

## C++14

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function to print the path from``// source (s) to destination (d)``void` `print(vector<``int``> parent, ``int` `s, ``int` `d)``{``  ` `  ``// The while loop will stop only when the``  ``// destination and the source node become equal``  ``while` `(s != d)``  ``{` `      ``// Print the destination and store the parent``      ``// of the node in the destination since parent``      ``// stores the node through which``      ``// the current node has been reached``      ``cout << d << ``" <- "``;``      ``d = parent[d];``  ``}``  ``cout << d << endl;``}` `// Finding Path using BFS ALgorithm``void` `bfs(vector > adjList, ``int` `source, ``int` `n)``{``    ``vector<``int``> parent(n, 0);``    ``vector<``int``> que(n, 0);` `    ``int` `front = -1, rear = -1;``    ``vector<``int``> visited(n, 0);``  ` `    ``//Arrays.fill(visited, 0);``    ``visited = 1;``    ``parent = source;` `    ``// To add any non visited node we will increment the rear``    ``// and add that vertex to the end of the array (enqueuing)``    ``que[++rear] = source;``    ``int` `k;` `    ``// The loop will continue till the rear and front are equal``    ``while` `(front != rear)``    ``{` `        ``// Here Dequeuing is nothing but to increment the front int``        ``k = que[++front];``      ` `        ``//L list = adjList.get(k);``        ``for` `(``int` `j:adjList[k])``        ``{``            ``if` `(visited[j] == 0)``            ``{``                ``que[++rear] = j;``                ``visited[j] = 1;``                ``parent[j] = k;``            ``}``        ``}``    ``}` `    ``// Print the path from source to every other node``    ``for` `(k = 0; k < n; k++)``        ``print(parent, source, k);``}` `// Driver code``int` `main()``{` `    ``// Adjacency list representation of the graph``    ``vector > adjList;` `    ``// Vertices 1 and 2 have an incoming edge``    ``// from vertex 0``    ``adjList.push_back({1, 2});` `    ``// Vertex 3 has an incoming edge``    ``// from vertex 1``    ``adjList.push_back({3});` `    ``// Vertices 0, 5 and 6 have an incoming``    ``// edge from vertex 2``    ``adjList.push_back({0, 5, 6});` `    ``// Vertices 1 and 4 have an incoming edge``    ``// from vertex 3``    ``adjList.push_back({1, 4});` `    ``// Vertices 2 and 3 have an incoming edge``    ``// from vertex 4``    ``adjList.push_back({2, 3});` `    ``// Vertices 4 and 6 have an incoming edge``    ``// from vertex 5``    ``adjList.push_back({4, 6});` `    ``// Vertex 5 has an incoming edge``    ``// from vertex 6``    ``adjList.push_back({5});``    ``int` `n = adjList.size();``    ``int` `source = 2;``    ``bfs(adjList, source, n);``}` `// This code is contributed by mohit kumar 29.`

## Java

 `// Java implementation of the approach``import` `java.util.ArrayList;``import` `java.util.Arrays;``import` `java.util.List;` `class` `GFG``{` `    ``// Function to print the path from``    ``// source (s) to destination (d)``    ``static` `void` `print(``int` `parent[], ``int` `s, ``int` `d)``    ``{``        ``// The while loop will stop only when the``        ``// destination and the source node become equal``        ``while` `(s != d) {` `            ``// Print the destination and store the parent``            ``// of the node in the destination since parent``            ``// stores the node through which``            ``// the current node has been reached``            ``System.out.print(d + ``" <- "``);``            ``d = parent[d];``        ``}` `        ``System.out.println(d);``    ``}` `    ``// Finding Path using BFS ALgorithm``    ``static` `void` `bfs(List > adjList, ``int` `source, ``int` `n)``    ``{``        ``int` `parent[] = ``new` `int``[n];``        ``int` `que[] = ``new` `int``[n];``        ``Arrays.fill(parent, ``0``);``        ``Arrays.fill(que, ``0``);` `        ``int` `front = -``1``, rear = -``1``;``        ``int` `visited[] = ``new` `int``[n];``        ``Arrays.fill(visited, ``0``);``        ``visited = ``1``;``        ``parent = source;` `        ``// To add any non visited node we will increment the rear``        ``// and add that vertex to the end of the array (enqueuing)``        ``que[++rear] = source;` `        ``int` `k;` `        ``// The loop will continue till the rear and front are equal``        ``while` `(front != rear) {` `            ``// Here Dequeuing is nothing but to increment the front int``            ``k = que[++front];``            ``List list = adjList.get(k);``            ``for` `(``int` `i = ``0``; i < list.size(); i++) {``                ``int` `j = list.get(i);``                ``if` `(visited[j] == ``0``) {``                    ``que[++rear] = j;``                    ``visited[j] = ``1``;``                    ``parent[j] = k;``                ``}``            ``}``        ``}` `        ``// Print the path from source to every other node``        ``for` `(k = ``0``; k < n; k++)``            ``print(parent, source, k);``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String args[])``    ``{` `        ``// Adjacency list representation of the graph``        ``List > adjList = ``new` `ArrayList<>();` `        ``// Vertices 1 and 2 have an incoming edge``        ``// from vertex 0``        ``List tmp = ``new` `ArrayList(Arrays.asList(``1``, ``2``));``        ``adjList.add(tmp);` `        ``// Vertex 3 has an incoming edge from vertex 1``        ``tmp = ``new` `ArrayList(Arrays.asList(``3``));``        ``adjList.add(tmp);` `        ``// Vertices 0, 5 and 6 have an incoming``        ``// edge from vertex 2``        ``tmp = ``new` `ArrayList(Arrays.asList(``0``, ``5``, ``6``));``        ``adjList.add(tmp);` `        ``// Vertices 1 and 4 have an incoming edge``        ``// from vertex 3``        ``tmp = ``new` `ArrayList(Arrays.asList(``1``, ``4``));``        ``adjList.add(tmp);` `        ``// Vertices 2 and 3 have an incoming edge``        ``// from vertex 4``        ``tmp = ``new` `ArrayList(Arrays.asList(``2``, ``3``));``        ``adjList.add(tmp);` `        ``// Vertices 4 and 6 have an incoming edge``        ``// from vertex 5``        ``tmp = ``new` `ArrayList(Arrays.asList(``4``, ``6``));``        ``adjList.add(tmp);` `        ``// Vertex 5 has an incoming edge from vertex 6``        ``tmp = ``new` `ArrayList(Arrays.asList(``5``));``        ``adjList.add(tmp);` `        ``int` `n = adjList.size();` `        ``int` `source = ``2``;``        ``bfs(adjList, source, n);``    ``}``}`

## Python3

 `# Python3 implementation of the approach` `# Function to print the path from``# src (s) to destination (d)``def` `printfunc(parent, s, d):``    ` `    ``# The while loop will stop only when``    ``# the destination and the src node``    ``# become equal``    ``while` `s !``=` `d:` `        ``# Print the destination and store``        ``# the parent of the node in the``        ``# destination since parent stores``        ``# the node through which the current``        ``# node has been reached``        ``print``(``str``(d) ``+` `" <-"``, end ``=` `" "``)``        ``d ``=` `parent[d]``        ` `    ``print``(d)` `# Finding Path using BFS ALgorithm``def` `bfs(adjList, src, n):``    ` `    ``parent ``=` `[``0``] ``*` `(n)``    ``que ``=` `[``0``] ``*` `(n)``    ` `    ``front, rear ``=` `-``1``, ``-``1``    ``visited ``=` `[``0``] ``*` `(n)``    ``visited[src] ``=` `1``    ``parent[src] ``=` `src` `    ``# To add any non visited node we will``    ``# increment the rear and add that vertex``    ``# to the end of the array (enqueuing)``    ``rear ``+``=` `1``    ``que[rear] ``=` `src` `    ``# The loop will continue till the rear``    ``# and front are equal``    ``while` `front !``=` `rear:` `        ``# Here Dequeuing is nothing but to``        ``# increment the front int``        ``front ``+``=` `1``        ``k ``=` `que[front]``        ``List` `=` `adjList[k]``        ``for` `i ``in` `range``(``0``, ``len``(``List``)):``            ``j ``=` `List``[i]``            ` `            ``if` `visited[j] ``=``=` `0``:``                ``rear ``+``=` `1``                ``que[rear] ``=` `j``                ``visited[j] ``=` `1``                ``parent[j] ``=` `k``                ` `    ``# Print the path from src to every``    ``# other node``    ``for` `k ``in` `range``(``0``, n):``        ``printfunc(parent, src, k)``    ` `# Driver code``if` `__name__ ``=``=` `"__main__"``:` `    ``# Adjacency list representation``    ``# of the graph``    ``adjList ``=` `[]` `    ``# Vertices 1 and 2 have an incoming edge``    ``# from vertex 0``    ``adjList.append([``1``, ``2``])` `    ``# Vertex 3 has an incoming edge``    ``# from vertex 1``    ``adjList.append([``3``])` `    ``# Vertices 0, 5 and 6 have an incoming``    ``# edge from vertex 2``    ``adjList.append([``0``, ``5``, ``6``])` `    ``# Vertices 1 and 4 have an incoming edge``    ``# from vertex 3``    ``adjList.append([``1``, ``4``])` `    ``# Vertices 2 and 3 have an incoming edge``    ``# from vertex 4``    ``adjList.append([``2``, ``3``])` `    ``# Vertices 4 and 6 have an incoming edge``    ``# from vertex 5``    ``adjList.append([``4``, ``6``])` `    ``# Vertex 5 has an incoming edge``    ``# from vertex 6``    ``adjList.append([``5``])` `    ``n ``=` `len``(adjList)` `    ``src ``=` `2``    ``bfs(adjList, src, n)``    ` `# This code is contributed by Rituraj Jain`

## Javascript

 ``
Output:
```0 <- 2
1 <- 0 <- 2
2
3 <- 1 <- 0 <- 2
4 <- 5 <- 2
5 <- 2
6 <- 2```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up