Skip to content
geeksforgeeks
  • Tutorials
    • Python
    • Java
    • Data Structures & Algorithms
    • ML & Data Science
    • Interview Corner
    • Programming Languages
    • Web Development
    • CS Subjects
    • DevOps And Linux
    • School Learning
    • Practice Coding Problems
  • Courses
    • DSA to Development
    • Get IBM Certification
    • Newly Launched!
      • Master Django Framework
      • Become AWS Certified
    • For Working Professionals
      • Interview 101: DSA & System Design
      • Data Science Training Program
      • JAVA Backend Development (Live)
      • DevOps Engineering (LIVE)
      • Data Structures & Algorithms in Python
    • For Students
      • Placement Preparation Course
      • Data Science (Live)
      • Data Structure & Algorithm-Self Paced (C++/JAVA)
      • Master Competitive Programming (Live)
      • Full Stack Development with React & Node JS (Live)
    • Full Stack Development
    • Data Science Program
    • All Courses
  • DSA
  • Interview Problems on Graph
  • Practice Graph
  • MCQs on Graph
  • Graph Tutorial
  • Graph Representation
  • Graph Properties
  • Types of Graphs
  • Graph Applications
  • BFS on Graph
  • DFS on Graph
  • Graph VS Tree
  • Transpose Graph
  • Dijkstra's Algorithm
  • Minimum Spanning Tree
  • Prim’s Algorithm
  • Topological Sorting
  • Floyd Warshall Algorithm
  • Strongly Connected Components
  • Advantages & Disadvantages
Open In App
Next Article:
Applications, Advantages and Disadvantages of Breadth First Search (BFS)
Next article icon

BFS for Disconnected Graph

Last Updated : 14 Sep, 2023
Comments
Improve
Suggest changes
Like Article
Like
Report

In the previous post, BFS only with a particular vertex is performed i.e. it is assumed that all vertices are reachable from the starting vertex. But in the case of a disconnected graph or any vertex that is unreachable from all vertex, the previous implementation will not give the desired output, so in this post, a modification is done in BFS. 


Dis1

 All vertices are reachable. So, for the above graph, simple BFS will work. 


Di2

 As in the above graph vertex 1 is unreachable from all vertex, so simple BFS wouldn't work for it.

Just to modify BFS, perform simple BFS from each 
unvisited vertex of given graph.

Following is the code when adjacency matrix representation is used for the graph.

C++ 
// C++ implementation of modified BFS for adjacency matrix // representation #include <iostream> #include <queue> using namespace std; void printBFS(int** edges, int V, int start, int* visited); void BFSHelper(int** edges, int V); void addEdge(int** edges, int f, int s);  void addEdge(int** edges, int f, int s) { edges[f][s] = 1; } void printBFS(int** edges, int V, int start, int* visited) {     if (V == 0)         return;     queue<int> BFS;     BFS.push(start);     visited[start] = 1;     while (!BFS.empty()) {         int data = BFS.front();         BFS.pop();         cout << data << " ";         for (int i = 0; i < V; i++) {             if (edges[data][i] == 1) {                 if (visited[i] == 0) {                     BFS.push(i);                     visited[i] = 1;                 }             }         }     } }  void BFSHelper(int** edges, int V) {     if (V == 0)         return;     int* visited = new int[V];     for (int i = 0; i < V; i++) {         visited[i] = 0;     }     for (int i = 0; i < V; i++) {         if (visited[i] == 0) {             printBFS(edges, V, i, visited);         }     } }  int main() {     int V = 5;     int E = 6;     if (E == 0) {         for (int i = 0; i < V; i++) {             cout << i << " ";         }         return 0;     }     int** edges = new int*[V];     for (int i = 0; i < V; i++) {         edges[i] = new int[V];         for (int j = 0; j < V; j++) {             edges[i][j] = 0;         }     }      addEdge(edges, 0, 4);     addEdge(edges, 1, 2);     addEdge(edges, 1, 3);     addEdge(edges, 1, 4);     addEdge(edges, 2, 3);     addEdge(edges, 3, 4);      BFSHelper(edges, V);     return 0; }
Java 
// Java implementation of modified BFS for adjacency matrix // representation  import java.io.*; import java.util.*;  class GFG {   static void addEdge(int[][] edges, int f, int s)   {     edges[f][s] = 1;   }    static void printBFS(int[][] edges, int V, int start,                        int[] visited)   {     if (V == 0)       return;     Queue<Integer> BFS = new LinkedList<Integer>();     BFS.add(start);     visited[start] = 1;     while (!BFS.isEmpty()) {       int data = BFS.poll();       System.out.print(data + " ");       for (int i = 0; i < V; i++) {         if (edges[data][i] == 1) {           if (visited[i] == 0) {             BFS.add(i);             visited[i] = 1;           }         }       }     }   }    static void bfsHelper(int[][] edges, int V)   {     if (V == 0)       return;     int[] visited = new int[V];     for (int i = 0; i < V; i++) {       visited[i] = 0;     }     for (int i = 0; i < V; i++) {       if (visited[i] == 0) {         printBFS(edges, V, i, visited);       }     }     System.out.println();   }    public static void main(String[] args)   {     int V = 5;     int E = 6;     if (E == 0) {       for (int i = 0; i < V; i++) {         System.out.print(i + " ");       }       System.out.println();       System.exit(0);     }     int[][] edges = new int[V][V];     for (int i = 0; i < V; i++) {       for (int j = 0; j < V; j++) {         edges[i][j] = 0;       }     }      addEdge(edges, 0, 4);     addEdge(edges, 1, 2);     addEdge(edges, 1, 3);     addEdge(edges, 1, 4);     addEdge(edges, 2, 3);     addEdge(edges, 3, 4);      bfsHelper(edges, V);   } }  // This code is contributed by cavi4762.
Python3 
import queue  def add_edge(edges, f, s):     edges[f][s] = 1  def print_bfs(edges, V, start, visited):     if V == 0:         return     bfs = queue.Queue()     bfs.put(start)     visited[start] = 1     while not bfs.empty():         data = bfs.get()         print(data, end=' ')         for i in range(V):             if edges[data][i] == 1:                 if visited[i] == 0:                     bfs.put(i)                     visited[i] = 1  def bfs_helper(edges, V):     if V == 0:         return     visited = [0] * V     for i in range(V):         if visited[i] == 0:             print_bfs(edges, V, i, visited)  if __name__ == "__main__":     V = 5     E = 6     if E == 0:         for i in range(V):             print(i, end=' ')         exit()      edges = [[0 for _ in range(V)] for _ in range(V)]      add_edge(edges, 0, 4)     add_edge(edges, 1, 2)     add_edge(edges, 1, 3)     add_edge(edges, 1, 4)     add_edge(edges, 2, 3)     add_edge(edges, 3, 4)      bfs_helper(edges, V)
C# 
// C# implementation of modified BFS for adjacency matrix // representation  using System; using System.Collections.Generic;  class Gfg {   static void AddEdge(int[, ] edges, int f, int s)   {     edges[f, s] = 1;   }    static void PrintBFS(int[, ] edges, int V, int start,                        int[] visited)   {     if (V == 0)       return;     Queue<int> BFS = new Queue<int>();     BFS.Enqueue(start);     visited[start] = 1;     while (BFS.Count > 0) {       int data = BFS.Dequeue();       Console.Write(data + " ");       for (int i = 0; i < V; i++) {         if (edges[data, i] == 1) {           if (visited[i] == 0) {             BFS.Enqueue(i);             visited[i] = 1;           }         }       }     }   }    static void BFSHelper(int[, ] edges, int V)   {     if (V == 0)       return;     int[] visited = new int[V];     for (int i = 0; i < V; i++) {       visited[i] = 0;     }     for (int i = 0; i < V; i++) {       if (visited[i] == 0) {         PrintBFS(edges, V, i, visited);       }     }     Console.WriteLine();   }    static void Main(string[] args)   {     int V = 5;     int E = 6;     if (E == 0) {       for (int i = 0; i < V; i++) {         Console.Write(i + " ");       }       Console.WriteLine();       Environment.Exit(0);     }     int[, ] edges = new int[V, V];     for (int i = 0; i < V; i++) {       for (int j = 0; j < V; j++) {         edges[i, j] = 0;       }     }      AddEdge(edges, 0, 4);     AddEdge(edges, 1, 2);     AddEdge(edges, 1, 3);     AddEdge(edges, 1, 4);     AddEdge(edges, 2, 3);     AddEdge(edges, 3, 4);      BFSHelper(edges, V);   } }  // This code is contributed by cavi4762.
JavaScript 
    // Javascript implementation of modified BFS for adjacency matrix representation        class Queue {         constructor() {           this.items = [];         }          // add element to the queue         push(element) {           return this.items.push(element);         }          // remove element from the queue         pop() {           if (this.items.length > 0) {             return this.items.shift();           }         }          // view the first element         front() {           return this.items[0];         }          // check if the queue is empty         empty() {           return this.items.length == 0;         }       }        function addEdge(edges, f, s) {         edges[f][s] = 1;       }       function printBFS(edges, V, start, visited) {         if (V == 0) return;         let BFS = new Queue();         BFS.push(start);         visited[start] = 1;         while (!BFS.empty()) {           data = BFS.front();           BFS.pop();           console.log(data);           for (let i = 0; i < V; i++) {             if (edges[data][i] == 1) {               if (visited[i] == 0) {                 BFS.push(i);                 visited[i] = 1;               }             }           }         }       }        function BFSHelper(edges, V) {         if (V == 0) return;         let visited = new Array(V);         for (let i = 0; i < V; i++) {           visited[i] = 0;         }         for (let i = 0; i < V; i++) {           if (visited[i] == 0) {             printBFS(edges, V, i, visited);           }         }       }        let V = 5;       let E = 6;       if (E == 0) {         for (let i = 0; i < V; i++) {           console.log(i);         }       }        let edges = Array.from(Array(V), () => new Array(V));       for (let i = 0; i < V; i++) {         for (let j = 0; j < V; j++) {           edges[i][j] = 0;         }       }        addEdge(edges, 0, 4);       addEdge(edges, 1, 2);       addEdge(edges, 1, 3);       addEdge(edges, 1, 4);       addEdge(edges, 2, 3);       addEdge(edges, 3, 4);        BFSHelper(edges, V);

Output
0 4 1 2 3

The time complexity of this algorithm is O(V + E), where V is the number of vertices and E is the number of edges. This is because we traverse each vertex and each edge once. 

The space complexity is O(V), since we use an array to store the visited vertices.

Following is the code when adjacency list representation is used for the graph.

C++ 
// C++ implementation of modified BFS #include<bits/stdc++.h> using namespace std;  // A utility function to add an edge in an // directed graph. void addEdge(vector<int> adj[], int u, int v) {     adj[u].push_back(v); }  // A utility function to do BFS of graph // from a given vertex u. void BFSUtil(int u, vector<int> adj[],             vector<bool> &visited) {      // Create a queue for BFS     list<int> q;       // Mark the current node as visited and enqueue it     visited[u] = true;     q.push_back(u);       // 'i' will be used to get all adjacent vertices 4     // of a vertex list<int>::iterator i;       while(!q.empty())     {         // Dequeue a vertex from queue and print it         u = q.front();         cout << u << " ";         q.pop_front();           // Get all adjacent vertices of the dequeued         // vertex s. If an adjacent has not been visited,          // then mark it visited and enqueue it         for (int i = 0; i != adj[u].size(); ++i)         {             if (!visited[adj[u][i]])             {                 visited[adj[u][i]] = true;                 q.push_back(adj[u][i]);             }         }     } }  // This function does BFSUtil() for all  // unvisited vertices. void BFS(vector<int> adj[], int V) {     vector<bool> visited(V, false);     for (int u=0; u<V; u++)         if (visited[u] == false)             BFSUtil(u, adj, visited); }  // Driver code int main() {     int V = 5;     vector<int> adj[V];      addEdge(adj, 0, 4);     addEdge(adj, 1, 2);     addEdge(adj, 1, 3);     addEdge(adj, 1, 4);     addEdge(adj, 2, 3);     addEdge(adj, 3, 4);     BFS(adj, V);     return 0; }
Java 
// Java implementation of modified BFS  import java.util.*; public class graph  {     //Implementing graph using HashMap     static HashMap<Integer,LinkedList<Integer>> graph=new HashMap<>();      //utility function to add edge in an undirected graph public static void addEdge(int a,int b) {     if(graph.containsKey(a))     {         LinkedList<Integer> l=graph.get(a);         l.add(b);         graph.put(a,l);     }     else     {         LinkedList<Integer> l=new LinkedList<>();         l.add(b);         graph.put(a,l);     } }  //Helper function for BFS  public static void bfshelp(int s,ArrayList<Boolean> visited) {     // Create a queue for BFS      LinkedList<Integer> q=new LinkedList<>();          // Mark the current node as visited and enqueue it      q.add(s);     visited.set(s,true);          while(!q.isEmpty())     {         // Dequeue a vertex from queue and print it          int f=q.poll();         System.out.print(f+" ");                  //Check whether the current node is                  //connected to any other node or not         if(graph.containsKey(f))         {         Iterator<Integer> i=graph.get(f).listIterator();                  // Get all adjacent vertices of the dequeued          // vertex f. If an adjacent has not been visited,           // then mark it visited and enqueue it                       while(i.hasNext())             {                 int n=i.next();                 if(!visited.get(n))                 {                 visited.set(n,true);                 q.add(n);                 }             }         }     }      }  //BFS function to check each node public static void bfs(int vertex) {     ArrayList<Boolean> visited=new ArrayList<Boolean>();     //Marking each node as unvisited     for(int i=0;i<vertex;i++)     {         visited.add(i,false);     }     for(int i=0;i<vertex;i++)     {         //Checking whether the node is visited or not         if(!visited.get(i))         {             bfshelp(i,visited);         }     } }  //Driver Code-The main function     public static void main(String[] args)      {         int v=5;         addEdge(0, 4);          addEdge(1, 2);          addEdge(1, 3);          addEdge(1, 4);          addEdge(2, 3);          addEdge(3, 4);          bfs(v);     }  }
Python3 
# Python3 implementation of modified BFS  import queue  # A utility function to add an edge  # in an undirected graph.  def addEdge(adj, u, v):     adj[u].append(v)  # A utility function to do BFS of  # graph from a given vertex u.  def BFSUtil(u, adj, visited):      # Create a queue for BFS      q = queue.Queue()          # Mark the current node as visited     # and enqueue it      visited[u] = True     q.put(u)           # 'i' will be used to get all adjacent      # vertices 4 of a vertex list<int>::iterator i           while(not q.empty()):                  # Dequeue a vertex from queue          # and print it          u = q.queue[0]          print(u, end = " ")          q.get()               # Get all adjacent vertices of the          # dequeued vertex s. If an adjacent          # has not been visited, then mark          # it visited and enqueue it          i = 0         while i != len(adj[u]):             if (not visited[adj[u][i]]):                     visited[adj[u][i]] = True                     q.put(adj[u][i])             i += 1  # This function does BFSUtil() for all  # unvisited vertices.  def BFS(adj, V):     visited = [False] * V      for u in range(V):         if (visited[u] == False):              BFSUtil(u, adj, visited)  # Driver code  if __name__ == '__main__':      V = 5     adj = [[] for i in range(V)]       addEdge(adj, 0, 4)      addEdge(adj, 1, 2)      addEdge(adj, 1, 3)      addEdge(adj, 1, 4)      addEdge(adj, 2, 3)      addEdge(adj, 3, 4)      BFS(adj, V)  # This code is contributed by PranchalK
C# 
// C# implementation of modified BFS  using System; using System.Collections.Generic;  class Graph  {      //Implementing graph using Dictionary      static Dictionary<int,List<int>> graph =              new Dictionary<int,List<int>>();   //utility function to add edge in an undirected graph  public static void addEdge(int a, int b)  {      if(graph.ContainsKey(a))      {          List<int> l = graph[a];          l.Add(b);          if(graph.ContainsKey(a))             graph[a] = l;         else             graph.Add(a,l);      }      else     {          List<int> l = new List<int>();          l.Add(b);          graph.Add(a, l);      }  }   // Helper function for BFS  public static void bfshelp(int s, List<Boolean> visited)  {      // Create a queue for BFS      List<int> q = new List<int>();           // Mark the current node as visited and enqueue it      q.Add(s);      visited.RemoveAt(s);     visited.Insert(s,true);           while(q.Count != 0)      {          // Dequeue a vertex from queue and print it          int f = q[0];          q.RemoveAt(0);         Console.Write(f + " ");                   //Check whether the current node is          //connected to any other node or not          if(graph.ContainsKey(f))          {                   // Get all adjacent vertices of the dequeued          // vertex f. If an adjacent has not been visited,          // then mark it visited and enqueue it                       foreach(int iN in graph[f])              {                  int n = iN;                  if(!visited[n])                  {                      visited.RemoveAt(n);                     visited.Insert(n, true);                      q.Add(n);                  }              }          }      }       }   // BFS function to check each node  public static void bfs(int vertex)  {      List<Boolean> visited = new List<Boolean>();           // Marking each node as unvisited      for(int i = 0; i < vertex; i++)      {          visited.Insert(i, false);      }      for(int i = 0; i < vertex; i++)      {          // Checking whether the node is visited or not          if(!visited[i])          {              bfshelp(i, visited);          }      }  }   // Driver Code  public static void Main(String[] args)  {      int v = 5;      addEdge(0, 4);      addEdge(1, 2);      addEdge(1, 3);      addEdge(1, 4);      addEdge(2, 3);      addEdge(3, 4);      bfs(v);  }  }   // This code is contributed by Rajput-Ji
JavaScript 
// JavaScript implementation of modified BFS  class Graph {   constructor() {     this.graph = new Map(); // Implementing graph using Map   }    // utility function to add edge in an undirected graph   addEdge(a, b) {     if (this.graph.has(a)) {       let l = this.graph.get(a);       l.push(b);       this.graph.set(a, l);     } else {       this.graph.set(a, [b]);     }   }    // Helper function for BFS    bfshelp(s, visited) {     // Create a queue for BFS      let q = [];     // Mark the current node as visited and enqueue it      q.push(s);     visited[s] = true;      while (q.length > 0) {       // Dequeue a vertex from queue and print it        let f = q.shift();       console.log(f + " ");        // Check whether the current node is connected to any other node or not       if (this.graph.has(f)) {         let l = this.graph.get(f);         for (let n of l) {           // Get all adjacent vertices of the dequeued vertex f.            // If an adjacent has not been visited, then mark it visited and enqueue it            if (!visited[n]) {             visited[n] = true;             q.push(n);           }         }       }     }   }    // BFS function to check each node   bfs(vertex) {     let visited = Array(vertex).fill(false);     // Marking each node as unvisited     for (let i = 0; i < vertex; i++) {       // Checking whether the node is visited or not       if (!visited[i]) {         this.bfshelp(i, visited);       }     }   } }  // Driver Code-The main function let g = new Graph(); let v = 5; g.addEdge(0, 4);  g.addEdge(1, 2);  g.addEdge(1, 3);  g.addEdge(1, 4);  g.addEdge(2, 3);  g.addEdge(3, 4);  g.bfs(v);   //This code is contributed by shivamsharma215

Output
0 4 1 2 3

The time complexity of the given BFS algorithm is O(V + E), where V is the number of vertices and E is the number of edges in the graph. 

The space complexity is also O(V + E) since we need to store the adjacency list and the visited array.

 


Next Article
Applications, Advantages and Disadvantages of Breadth First Search (BFS)

K

kartik
Improve
Article Tags :
  • Graph
  • DSA
  • BFS
Practice Tags :
  • BFS
  • Graph

Similar Reads

    Breadth First Search or BFS for a Graph
    Given a undirected graph represented by an adjacency list adj, where each adj[i] represents the list of vertices connected to vertex i. Perform a Breadth First Search (BFS) traversal starting from vertex 0, visiting vertices from left to right according to the adjacency list, and return a list conta
    15+ min read

    BFS in different language

    C Program for Breadth First Search or BFS for a Graph
    The Breadth First Search (BFS) algorithm is used to search a graph data structure for a node that meets a set of criteria. It starts at the root of the graph and visits all nodes at the current depth level before moving on to the nodes at the next depth level. Relation between BFS for Graph and Tree
    3 min read
    Java Program for Breadth First Search or BFS for a Graph
    The Breadth First Search (BFS) algorithm is used to search a graph data structure for a node that meets a set of criteria. It starts at the root of the graph and visits all nodes at the current depth level before moving on to the nodes at the next depth level. Relation between BFS for Graph and Tree
    3 min read
    Breadth First Search or BFS for a Graph in Python
    Breadth First Search (BFS) is a fundamental graph traversal algorithm. It begins with a node, then first traverses all its adjacent nodes. Once all adjacent are visited, then their adjacent are traversed. BFS is different from DFS in a way that closest vertices are visited before others. We mainly t
    4 min read
    BFS for Disconnected Graph
    In the previous post, BFS only with a particular vertex is performed i.e. it is assumed that all vertices are reachable from the starting vertex. But in the case of a disconnected graph or any vertex that is unreachable from all vertex, the previous implementation will not give the desired output, s
    14 min read
    Applications, Advantages and Disadvantages of Breadth First Search (BFS)
    We have earlier discussed Breadth First Traversal Algorithm for Graphs. Here in this article, we will see the applications, advantages, and disadvantages of the Breadth First Search. Applications of Breadth First Search: 1. Shortest Path and Minimum Spanning Tree for unweighted graph: In an unweight
    4 min read
    Breadth First Traversal ( BFS ) on a 2D array
    Given a matrix of size M x N consisting of integers, the task is to print the matrix elements using Breadth-First Search traversal. Examples: Input: grid[][] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}}Output: 1 2 5 3 6 9 4 7 10 13 8 11 14 12 15 16 Input: grid[][] = {{-1, 0, 0,
    9 min read
    0-1 BFS (Shortest Path in a Binary Weight Graph)
    Given an undirected graph where every edge has a weight as either 0 or 1. The task is to find the shortest path from the source vertex to all other vertices in the graph.Example: Input: Source Vertex = 0 and below graph Having vertices like (u, v, w): edges: [[0,1,0], [0, 7, 1], [1,2,1], [1, 7, 1],
    10 min read

    Variations of BFS implementations

    Implementation of BFS using adjacency matrix
    Breadth First Search (BFS) has been discussed in this article which uses adjacency list for the graph representation. In this article, adjacency matrix will be used to represent the graph.Adjacency matrix representation: In adjacency matrix representation of a graph, the matrix mat[][] of size n*n (
    7 min read
    BFS using STL for competitive coding
    A STL based simple implementation of BFS using queue and vector in STL. The adjacency list is represented using vectors of vector.  In BFS, we start with a node. Create a queue and enqueue source into it. Mark source as visited.While queue is not empty, do followingDequeue a vertex from queue. Let t
    5 min read
    Breadth First Search without using Queue
    Breadth-first search is a graph traversal algorithm which traverse a graph or tree level by level. In this article, BFS for a Graph is implemented using Adjacency list without using a Queue.Examples: Input: Output: BFS traversal = 2, 0, 3, 1 Explanation: In the following graph, we start traversal fr
    8 min read
    BFS using vectors & queue as per the algorithm of CLRS
    Breadth-first search traversal of a graph using the algorithm given in CLRS book. BFS is one of the ways to traverse a graph. It is named so because it expands the frontier between discovered and undiscovered vertices uniformly across the breadth of the frontier. What it means is that the algorithm
    11 min read

    Easy problems on BFS

    Find if there is a path between two vertices in a directed graph
    Given a Directed Graph and two vertices src and dest, check whether there is a path from src to dest.Example: Consider the following Graph: adj[][] = [ [], [0, 2], [0, 3], [], [2] ]Input : src = 1, dest = 3Output: YesExplanation: There is a path from 1 to 3, 1 -> 2 -> 3Input : src = 0, dest =
    11 min read
    Find if there is a path between two vertices in an undirected graph
    Given an undirected graph with N vertices and E edges and two vertices (U, V) from the graph, the task is to detect if a path exists between these two vertices. Print "Yes" if a path exists and "No" otherwise. Examples: U = 1, V = 2 Output: No Explanation: There is no edge between the two points and
    15+ min read
    Print all the levels with odd and even number of nodes in it | Set-2
    Given an N-ary tree, print all the levels with odd and even number of nodes in it. Examples: For example consider the following tree 1 - Level 1 / \ 2 3 - Level 2 / \ \ 4 5 6 - Level 3 / \ / 7 8 9 - Level 4 The levels with odd number of nodes are: 1 3 4 The levels with even number of nodes are: 2 No
    12 min read
    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:
    14 min read
    Find all reachable nodes from every node present in a given set
    Given an undirected graph and a set of vertices, find all reachable nodes from every vertex present in the given set.Consider below undirected graph with 2 disconnected components.  arr[] = {1 , 2 , 5}Reachable nodes from 1 are 1, 2, 3, 4Reachable nodes from 2 are 1, 2, 3, 4Reachable nodes from 5 ar
    12 min read
    Program to print all the non-reachable nodes | Using BFS
    Given an undirected graph and a set of vertices, we have to print all the non-reachable nodes from the given head node using a breadth-first search. For example: Consider below undirected graph with two disconnected components: In this graph, if we consider 0 as a head node, then the node 0, 1 and 2
    8 min read
    Check whether a given graph is Bipartite or not
    Given a graph with V vertices numbered from 0 to V-1 and a list of edges, determine whether the graph is bipartite or not.Note: A bipartite graph is a type of graph where the set of vertices can be divided into two disjoint sets, say U and V, such that every edge connects a vertex in U to a vertex i
    8 min read
    Print all paths from a given source to a destination using BFS
    Given a directed graph, a source vertex ‘src’ and a destination vertex ‘dst’, print all paths from given ‘src’ to ‘dst’. Please note that in the cases, we have cycles in the graph, we need not to consider paths have cycles as in case of cycles, there can by infinitely many by doing multiple iteratio
    9 min read
    Minimum steps to reach target by a Knight | Set 1
    Given a square chessboard of n x n size, the position of the Knight and the position of a target are given. We need to find out the minimum steps a Knight will take to reach the target position.Examples: Input: KnightknightPosition: (1, 3) , targetPosition: (5, 0)Output: 3Explanation: In above diagr
    9 min read

    Intermediate problems on BFS

    Traversal of a Graph in lexicographical order using BFS
    C++ // C++ program to implement // the above approach #include <bits/stdc++.h> using namespace std; // Function to traverse the graph in // lexicographical order using BFS void LexiBFS(map<char, set<char> >& G, char S, map<char, bool>& vis) { // Stores nodes of the gr
    8 min read
    Detect cycle in an undirected graph using BFS
    Given an undirected graph, the task is to determine if cycle is present in it or not.Examples:Input: V = 5, edges[][] = [[0, 1], [0, 2], [0, 3], [1, 2], [3, 4]]Undirected Graph with 5 NodeOutput: trueExplanation: The diagram clearly shows a cycle 0 → 2 → 1 → 0.Input: V = 4, edges[][] = [[0, 1], [1,
    6 min read
    Detect Cycle in a Directed Graph using BFS
    Given a directed graph, check whether the graph contains a cycle or not. Your function should return true if the given graph contains at least one cycle, else return false. For example, the following graph contains two cycles 0->1->2->3->0 and 2->4->2, so your function must return
    11 min read
    Minimum number of edges between two vertices of a Graph
    You are given an undirected graph G(V, E) with N vertices and M edges. We need to find the minimum number of edges between a given pair of vertices (u, v). Examples: Input: For given graph G. Find minimum number of edges between (1, 5). Output: 2Explanation: (1, 2) and (2, 5) are the only edges resu
    8 min read
    Word Ladder - Shortest Chain To Reach Target Word
    Given an array of strings arr[], and two different strings start and target, representing two words. The task is to find the length of the smallest chain from string start to target, such that only one character of the adjacent words differs and each word exists in arr[].Note: Print 0 if it is not p
    15 min read
    Print the lexicographically smallest BFS of the graph starting from 1
    Given a connected graph with N vertices and M edges. The task is to print the lexicographically smallest BFS traversal of the graph starting from 1. Note: The vertices are numbered from 1 to N.Examples: Input: N = 5, M = 5 Edges: 1 4 3 4 5 4 3 2 1 5 Output: 1 4 3 2 5 Start from 1, go to 4, then to 3
    7 min read
    Shortest path in an unweighted graph
    Given an unweighted, undirected graph of V nodes and E edges, a source node S, and a destination node D, we need to find the shortest path from node S to node D in the graph. Input: V = 8, E = 10, S = 0, D = 7, edges[][] = {{0, 1}, {1, 2}, {0, 3}, {3, 4}, {4, 7}, {3, 7}, {6, 7}, {4, 5}, {4, 6}, {5,
    11 min read
    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 shorte
    11 min read
    Distance of nearest cell having 1 in a binary matrix
    Given a binary grid of n*m. Find the distance of the nearest 1 in the grid for each cell.The distance is calculated as |i1  - i2| + |j1 - j2|, where i1, j1 are the row number and column number of the current cell, and i2, j2 are the row number and column number of the nearest cell having value 1. Th
    15+ min read

    Hard Problems on BFS

    Islands in a graph using BFS
    Given an n x m grid of 'W' (Water) and 'L' (Land), the task is to count the number of islands. An island is a group of adjacent 'L' cells connected horizontally, vertically, or diagonally, and it is surrounded by water or the grid boundary. The goal is to determine how many distinct islands exist in
    15+ min read
    Print all shortest paths between given source and destination in an undirected graph
    Given an undirected and unweighted graph and two nodes as source and destination, the task is to print all the paths of the shortest length between the given source and destination.Examples: Input: source = 0, destination = 5 Output: 0 -> 1 -> 3 -> 50 -> 2 -> 3 -> 50 -> 1 ->
    13 min read
    Count Number of Ways to Reach Destination in a Maze using BFS
    Given a maze of dimensions n x m represented by the matrix mat, where mat[i][j] = -1 represents a blocked cell and mat[i][j] = 0 represents an unblocked cell, the task is to count the number of ways to reach the bottom-right cell starting from the top-left cell by moving right (i, j+1) or down (i+1,
    8 min read
    Coin Change | BFS Approach
    Given an integer X and an array arr[] of length N consisting of positive integers, the task is to pick minimum number of integers from the array such that they sum up to N. Any number can be chosen infinite number of times. If no answer exists then print -1.Examples: Input: X = 7, arr[] = {3, 5, 4}
    6 min read
    Water Jug problem using BFS
    Given two empty jugs of m and n litres respectively. The jugs don't have markings to allow measuring smaller quantities. You have to use the jugs to measure d litres of water. The task is to find the minimum number of operations to be performed to obtain d litres of water in one of the jugs. In case
    12 min read
    Word Ladder - Set 2 ( Bi-directional BFS )
    Given a dictionary, and two words start and target (both of the same length). Find length of the smallest chain from start to target if it exists, such that adjacent words in the chain only differ by one character and each word in the chain is a valid word i.e., it exists in the dictionary. It may b
    15+ min read
    Implementing Water Supply Problem using Breadth First Search
    Given N cities that are connected using N-1 roads. Between Cities [i, i+1], there exists an edge for all i from 1 to N-1.The task is to set up a connection for water supply. Set the water supply in one city and water gets transported from it to other cities using road transport. Certain cities are b
    10 min read
    Minimum Cost Path in a directed graph via given set of intermediate nodes
    Given a weighted, directed graph G, an array V[] consisting of vertices, the task is to find the Minimum Cost Path passing through all the vertices of the set V, from a given source S to a destination D. Examples: Input: V = {7}, S = 0, D = 6 Output: 11 Explanation: Minimum path 0->7->5->6.
    10 min read
    Shortest path in a Binary Maze
    Given an M x N matrix where each element can either be 0 or 1. We need to find the shortest path between a given source cell to a destination cell. The path can only be created out of a cell if its value is 1.Note: You can move into an adjacent cell in one of the four directions, Up, Down, Left, and
    15+ min read
    Minimum cost to traverse from one index to another in the String
    Given a string S of length N consisting of lower case character, the task is to find the minimum cost to reach from index i to index j. At any index k, the cost to jump to the index k+1 and k-1(without going out of bounds) is 1. Additionally, the cost to jump to any index m such that S[m] = S[k] is
    10 min read
geeksforgeeks-footer-logo
Corporate & Communications Address:
A-143, 7th Floor, Sovereign Corporate Tower, Sector- 136, Noida, Uttar Pradesh (201305)
Registered Address:
K 061, Tower K, Gulshan Vivante Apartment, Sector 137, Noida, Gautam Buddh Nagar, Uttar Pradesh, 201305
GFG App on Play Store GFG App on App Store
Advertise with us
  • Company
  • About Us
  • Legal
  • Privacy Policy
  • In Media
  • Contact Us
  • Advertise with us
  • GFG Corporate Solution
  • Placement Training Program
  • Languages
  • Python
  • Java
  • C++
  • PHP
  • GoLang
  • SQL
  • R Language
  • Android Tutorial
  • Tutorials Archive
  • DSA
  • Data Structures
  • Algorithms
  • DSA for Beginners
  • Basic DSA Problems
  • DSA Roadmap
  • Top 100 DSA Interview Problems
  • DSA Roadmap by Sandeep Jain
  • All Cheat Sheets
  • Data Science & ML
  • Data Science With Python
  • Data Science For Beginner
  • Machine Learning
  • ML Maths
  • Data Visualisation
  • Pandas
  • NumPy
  • NLP
  • Deep Learning
  • Web Technologies
  • HTML
  • CSS
  • JavaScript
  • TypeScript
  • ReactJS
  • NextJS
  • Bootstrap
  • Web Design
  • Python Tutorial
  • Python Programming Examples
  • Python Projects
  • Python Tkinter
  • Python Web Scraping
  • OpenCV Tutorial
  • Python Interview Question
  • Django
  • Computer Science
  • Operating Systems
  • Computer Network
  • Database Management System
  • Software Engineering
  • Digital Logic Design
  • Engineering Maths
  • Software Development
  • Software Testing
  • DevOps
  • Git
  • Linux
  • AWS
  • Docker
  • Kubernetes
  • Azure
  • GCP
  • DevOps Roadmap
  • System Design
  • High Level Design
  • Low Level Design
  • UML Diagrams
  • Interview Guide
  • Design Patterns
  • OOAD
  • System Design Bootcamp
  • Interview Questions
  • Inteview Preparation
  • Competitive Programming
  • Top DS or Algo for CP
  • Company-Wise Recruitment Process
  • Company-Wise Preparation
  • Aptitude Preparation
  • Puzzles
  • School Subjects
  • Mathematics
  • Physics
  • Chemistry
  • Biology
  • Social Science
  • English Grammar
  • Commerce
  • World GK
  • GeeksforGeeks Videos
  • DSA
  • Python
  • Java
  • C++
  • Web Development
  • Data Science
  • CS Subjects
@GeeksforGeeks, Sanchhaya Education Private Limited, All rights reserved
We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox
Improvement
Suggest Changes
Help us improve. Share your suggestions to enhance the article. Contribute your expertise and make a difference in the GeeksforGeeks portal.
geeksforgeeks-suggest-icon
Create Improvement
Enhance the article with your expertise. Contribute to the GeeksforGeeks community and help create better learning resources for all.
geeksforgeeks-improvement-icon
Suggest Changes
min 4 words, max Words Limit:1000

Thank You!

Your suggestions are valuable to us.

What kind of Experience do you want to share?

Interview Experiences
Admission Experiences
Career Journeys
Work Experiences
Campus Experiences
Competitive Exam Experiences