Finding the path from one vertex to rest using BFS
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.
