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:

## 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<List<Integer> > 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<Integer> 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<List<Integer> > adjList = ` `new` `ArrayList<>(); ` ` ` ` ` `// Vertices 1 and 2 have an incoming edge ` ` ` `// from vertex 0 ` ` ` `List<Integer> tmp = ` `new` `ArrayList<Integer>(Arrays.asList(` `1` `, ` `2` `)); ` ` ` `adjList.add(tmp); ` ` ` ` ` `// Vertex 3 has an incoming edge from vertex 1 ` ` ` `tmp = ` `new` `ArrayList<Integer>(Arrays.asList(` `3` `)); ` ` ` `adjList.add(tmp); ` ` ` ` ` `// Vertices 0, 5 and 6 have an incoming ` ` ` `// edge from vertex 2 ` ` ` `tmp = ` `new` `ArrayList<Integer>(Arrays.asList(` `0` `, ` `5` `, ` `6` `)); ` ` ` `adjList.add(tmp); ` ` ` ` ` `// Vertices 1 and 4 have an incoming edge ` ` ` `// from vertex 3 ` ` ` `tmp = ` `new` `ArrayList<Integer>(Arrays.asList(` `1` `, ` `4` `)); ` ` ` `adjList.add(tmp); ` ` ` ` ` `// Vertices 2 and 3 have an incoming edge ` ` ` `// from vertex 4 ` ` ` `tmp = ` `new` `ArrayList<Integer>(Arrays.asList(` `2` `, ` `3` `)); ` ` ` `adjList.add(tmp); ` ` ` ` ` `// Vertices 4 and 6 have an incoming edge ` ` ` `// from vertex 5 ` ` ` `tmp = ` `new` `ArrayList<Integer>(Arrays.asList(` `4` `, ` `6` `)); ` ` ` `adjList.add(tmp); ` ` ` ` ` `// Vertex 5 has an incoming edge from vertex 6 ` ` ` `tmp = ` `new` `ArrayList<Integer>(Arrays.asList(` `5` `)); ` ` ` `adjList.add(tmp); ` ` ` ` ` `int` `n = adjList.size(); ` ` ` ` ` `int` `source = ` `2` `; ` ` ` `bfs(adjList, source, n); ` ` ` `} ` `} ` |

*chevron_right*

*filter_none*

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

*chevron_right*

*filter_none*

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

## Recommended Posts:

- Check if incoming edges in a vertex of directed graph is equal to vertex itself or not
- Check if vertex X lies in subgraph of vertex Y for the given Graph
- Check if every vertex triplet in graph contains two vertices connected to third vertex
- Finding minimum vertex cover size of a graph using binary search
- Java Program for Finding the vertex, focus and directrix of a parabola
- 0-1 BFS (Shortest Path in a Binary Weight Graph)
- Maximize the number of uncolored vertices appearing along the path from root vertex and the colored vertices
- Maximum difference of count of black and white vertices in a path containing vertex V
- Sum of Nodes and respective Neighbors on the path from root to a vertex V
- Finding shortest path between any two nodes using Floyd Warshall Algorithm
- Building an undirected graph and finding shortest path using Dictionaries in Python
- Check if a given directed graph is strongly connected | Set 2 (Kosaraju using BFS)
- Print all paths from a given source to a destination using BFS
- Traversing directory in Java using BFS
- BFS using STL for competitive coding
- Water Jug problem using BFS
- Diameter of n-ary tree using BFS
- Level of Each node in a Tree from source node (using BFS)
- Count the number of nodes at given level in a tree using BFS.
- BFS using vectors & queue as per the algorithm of CLRS

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.