Islands in a graph using BFS

Last Updated : 04 Apr, 2025

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 the grid.

Examples:

Input: grid[][] = [[‘L', ‘L', ‘W', ‘W’, ‘W’],
[‘W', ‘L', ‘W’, ‘W', ‘L’],
[‘L’, ‘W’, ‘W’, ‘L’, ‘L’],
[‘W’, ‘W’, ‘W’, ‘W’, ‘W’],
['L’, ‘W’, ‘L’, ‘L', ‘W’]]
Output: 4
Explanation: The image below shows all the 4 islands in the graph
four islands in the matrix
Input: grid[][] = [[‘L', ‘L’],
[‘L', ‘L’]]
Output: 1
Explanation: All elements are 1, hence there is only one island

Input: grid[][] = [[‘W’, ‘W’],
[‘W’, ‘W’]]
Output: 0
Explanation: All elements are 0, hence no islands.

Table of Content

Approach:- Using BFS and Additional Matrix - O(rows * cols) Time and O(rows * cols) Space

We have discussed DFS solutions for islands. This problem can also solved by applying BFS on each component. A cell in 2D matrix can be connected to 8 neighbors. So, for every cell with value 'L, we process all 8 neighbors. We also keep track of the visited 1s so that they are not visited again.

Steps

Initialize a boolean matrix of the same size as the given matrix to keep track of visited cells.
Traverse the given matrix, and for each unvisited cell that is part of an island, perform BFS starting from that cell.
In the BFS algorithm, enqueue the current cell and mark it as visited. Then, while the queue is not empty, dequeue a cell and enqueue its unvisited neighbors that are part of the same island. Mark each of these neighbors as visited.
After BFS is complete, increment the island count by 1.
Repeat steps 2-4 until all unvisited cells have been processed.
Return the total island count.

C++

#include <bits/stdc++.h> using namespace std;  // A function to check if a given cell (r, c)  // can be included in BFS bool isSafe(vector<vector<char>>& grid, int r,              int c, vector<vector<bool>>& vis) {     int rows = grid.size();     int cols = grid[0].size();     return (r >= 0) && (r < rows) && (c >= 0) &&             (c < cols) && (grid[r][c] == 'L' && !vis[r][c]); }  // Breadth-First-Search to visit all cells in the  // current island void bfs(vector<vector<char>>& grid, vector<vector<bool>>& vis,                                          int sr, int sc) {        // These arrays are used to get row and     // column numbers of 8 neighbours of     // a given cell     vector<int> rNbr = { -1, -1, -1, 0, 0, 1, 1, 1 };     vector<int> cNbr = { -1,  0,  1, -1, 1, -1, 0, 1 };      // Simple BFS first step, we enqueue     // source and mark it as visited     queue<pair<int, int>> q;     q.push({sr, sc});     vis[sr][sc] = true;      // Next step of BFS. We take out     // items one by one from queue and     // enqueue their unvisited adjacent     while (!q.empty()) {         int r = q.front().first;         int c = q.front().second;         q.pop();          // Go through all 8 adjacent         for (int k = 0; k < 8; k++) {             int newR = r + rNbr[k];             int newC = c + cNbr[k];             if (isSafe(grid, newR, newC, vis)) {                 vis[newR][newC] = true;                 q.push({newR, newC});             }         }     } }  // This function returns the number of islands  // (connected components) in a graph int countIslands(vector<vector<char>>& grid) {        // Mark all cells as not visited     int rows = grid.size();     int cols = grid[0].size();     vector<vector<bool>> vis(rows, vector<bool>(cols, false));      // Call BFS for every unvisited vertex     // Whenever we see an unvisited vertex,     // we increment res (number of islands)     // also.     int res = 0;     for (int r = 0; r < rows; r++) {         for (int c = 0; c < cols; c++) {             if (grid[r][c] == 'L' && !vis[r][c]) {                 bfs(grid, vis, r, c);                 res++;             }         }     }      return res; }  int main() {     vector<vector<char>> grid = { { 'L', 'L', 'W', 'W', 'W' },                                   { 'W', 'L', 'W', 'W', 'L' },                                   { 'L', 'W', 'W', 'L', 'L' },                                   { 'W', 'W', 'W', 'W', 'W' },                                   { 'L', 'W', 'L', 'L', 'W' } };      cout << countIslands(grid) << endl;       return 0; }

Java

import java.util.LinkedList; import java.util.Queue;  class GfG {      // A function to check if a given cell (r, c)      // can be included in BFS     static boolean isSafe(char[][] grid, int r, int c, boolean[][] vis) {         int rows = grid.length;         int cols = grid[0].length;         return (r >= 0) && (r < rows) && (c >= 0) &&                 (c < cols) && (grid[r][c] == 'L' && !vis[r][c]);     }      // Breadth-First-Search to visit all cells in the current island     static void bfs(char[][] grid, boolean[][] vis, int sr, int sc) {         // These arrays are used to get row and column numbers of 8 neighbors         int[] rNbr = { -1, -1, -1, 0, 0, 1, 1, 1 };         int[] cNbr = { -1,  0,  1, -1, 1, -1, 0, 1 };          // Simple BFS first step, we enqueue source and mark it as visited         Queue<int[]> q = new LinkedList<>();         q.add(new int[]{sr, sc});         vis[sr][sc] = true;          // Process all items in the queue         while (!q.isEmpty()) {             int[] pos = q.poll();             int r = pos[0];             int c = pos[1];              // Explore all 8 adjacent cells             for (int k = 0; k < 8; k++) {                 int newR = r + rNbr[k];                 int newC = c + cNbr[k];                 if (isSafe(grid, newR, newC, vis)) {                     vis[newR][newC] = true;                     q.add(new int[]{newR, newC});                 }             }         }     }      // This function returns the number of islands (connected components) in a graph     static int countIslands(char[][] grid) {         int rows = grid.length;         int cols = grid[0].length;         boolean[][] vis = new boolean[rows][cols];          int res = 0; // Island count         for (int r = 0; r < rows; r++) {             for (int c = 0; c < cols; c++) {                 if (grid[r][c] == 'L' && !vis[r][c]) {                     bfs(grid, vis, r, c);                     res++;                 }             }         }          return res;     }      public static void main(String[] args) {         char[][] grid = {             {'L', 'L', 'W', 'W', 'W'},             {'W', 'L', 'W', 'W', 'L'},             {'L', 'W', 'W', 'L', 'L'},             {'W', 'W', 'W', 'W', 'W'},             {'L', 'W', 'L', 'L', 'W'}         };          System.out.println(countIslands(grid));       } }

Python

from collections import deque  # A function to check if a given cell (r, c) can be included in BFS def isSafe(grid, r, c, vis):     rows = len(grid)     cols = len(grid[0])     return (0 <= r < rows) and (0 <= c < cols) and (grid[r][c] == 'L' and not vis[r][c])  # Breadth-First-Search to visit all cells in the current island def bfs(grid, vis, sr, sc):     # These arrays are used to get row and column numbers of 8 neighbors     rNbr = [-1, -1, -1, 0, 0, 1, 1, 1]     cNbr = [-1,  0,  1, -1, 1, -1, 0, 1]      # Simple BFS first step, we enqueue source and mark it as visited     q = deque([(sr, sc)])     vis[sr][sc] = True      # Process all items in the queue     while q:         r, c = q.popleft()          # Explore all 8 adjacent cells         for k in range(8):             newR = r + rNbr[k]             newC = c + cNbr[k]             if isSafe(grid, newR, newC, vis):                 vis[newR][newC] = True                 q.append((newR, newC))  # This function returns the number of islands (connected components) in a grid def countIslands(grid):     rows = len(grid)     cols = len(grid[0])     vis = [[False] * cols for _ in range(rows)]      island_count = 0  # Island count     for r in range(rows):         for c in range(cols):             if grid[r][c] == 'L' and not vis[r][c]:                 bfs(grid, vis, r, c)                 island_count += 1      return island_count  # Driver Code if __name__ == "__main__":     grid = [         ['L', 'L', 'W', 'W', 'W'],         ['W', 'L', 'W', 'W', 'L'],         ['L', 'W', 'W', 'L', 'L'],         ['W', 'W', 'W', 'W', 'W'],         ['L', 'W', 'L', 'L', 'W']     ]      print(countIslands(grid))

using System; using System.Collections.Generic;  class GfG {        // A function to check if a given cell (r, c) can be included in BFS     static bool IsSafe(char[][] grid, int r, int c, bool[][] vis) {         int rows = grid.Length;         int cols = grid[0].Length;         return (r >= 0) && (r < rows) && (c >= 0) &&                 (c < cols) && (grid[r][c] == 'L' && !vis[r][c]);     }      // Breadth-First-Search to visit all cells in the current island     static void bfs(char[][] grid, bool[][] vis, int sr, int sc) {                // These arrays are used to get row and column numbers of 8 neighbors         int[] rNbr = { -1, -1, -1, 0, 0, 1, 1, 1 };         int[] cNbr = { -1,  0,  1, -1, 1, -1, 0, 1 };          // Simple BFS first step, we enqueue source and mark it as visited         Queue<(int, int)> q = new Queue<(int, int)>();         q.Enqueue((sr, sc));         vis[sr][sc] = true;          // Process all items in the queue         while (q.Count > 0) {             var (r, c) = q.Dequeue();              // Explore all 8 adjacent cells             for (int k = 0; k < 8; k++) {                 int newR = r + rNbr[k];                 int newC = c + cNbr[k];                 if (IsSafe(grid, newR, newC, vis)) {                     vis[newR][newC] = true;                     q.Enqueue((newR, newC));                 }             }         }     }      // This function returns the number of islands (connected components) in a grid     static int countIslands(char[][] grid) {                // Mark all cells as not visited         int rows = grid.Length;         int cols = grid[0].Length;         bool[][] vis = new bool[rows][];         for (int i = 0; i < rows; i++) {             vis[i] = new bool[cols];         }          int islandCount = 0; // Island count         for (int r = 0; r < rows; r++) {             for (int c = 0; c < cols; c++) {                 if (grid[r][c] == 'L' && !vis[r][c]){                     bfs(grid, vis, r, c);                     islandCount++;                 }             }         }          return islandCount;     }      static void Main() {         char[][] grid = new char[][] {             new char[] { 'L', 'L', 'W', 'W', 'W' },             new char[] { 'W', 'L', 'W', 'W', 'L' },             new char[] { 'L', 'W', 'W', 'L', 'L' },             new char[] { 'W', 'W', 'W', 'W', 'W' },             new char[] { 'L', 'W', 'L', 'L', 'W' }         };          Console.WriteLine(countIslands(grid));      } }

JavaScript

// A function to check if a given cell (r, c) can be included in BFS function isSafe(grid, r, c, vis) {     const rows = grid.length;     const cols = grid[0].length;     return (r >= 0) && (r < rows) && (c >= 0) &&             (c < cols) && (grid[r][c] === 'L' && !vis[r][c]); }  // Breadth-First-Search to visit all cells in the current island function bfs(grid, vis, sr, sc) {     // These arrays are used to get row and column numbers of 8 neighbors     const rNbr = [ -1, -1, -1, 0, 0, 1, 1, 1 ];     const cNbr = [ -1, 0, 1, -1, 1, -1, 0, 1 ];      // Simple BFS first step, we enqueue source and mark it as visited     const queue = [];     queue.push([sr, sc]);     vis[sr][sc] = true;      // Process all items in the queue     while (queue.length > 0) {         const [r, c] = queue.shift();          // Explore all 8 adjacent cells         for (let k = 0; k < 8; k++) {             const newR = r + rNbr[k];             const newC = c + cNbr[k];             if (isSafe(grid, newR, newC, vis)) {                 vis[newR][newC] = true;                 queue.push([newR, newC]);             }         }     } }  // This function returns the number of islands (connected components) in a grid function countIslands(grid) {     // Mark all cells as not visited     const rows = grid.length;     const cols = grid[0].length;     const vis = Array.from({ length: rows }, () => Array(cols).fill(false));      let islandCount = 0; // Island count     for (let r = 0; r < rows; r++) {         for (let c = 0; c < cols; c++) {             if (grid[r][c] === 'L' && !vis[r][c]) {                 bfs(grid, vis, r, c);                 islandCount++;             }         }     }      return islandCount; }  // Example usage const grid = [     ['L', 'L', 'W', 'W', 'W'],     ['W', 'L', 'W', 'W', 'L'],     ['L', 'W', 'W', 'L', 'L'],     ['W', 'W', 'W', 'W', 'W'],     ['L', 'W', 'L', 'L', 'W'] ];  console.log(countIslands(grid));

Output

Space Optimized Approach:- Using Space Optimized BFS - O(rows * cols) Time and O(rows + cols) Space

The idea is instead of using an additional matrix vis[][] to keep track of the visited nodes, we can change the original input matrix by marking the visited cells as 'W'. So, every time we visit a cell with value 'L', we update its value to 'W' to avoid revisiting the same cell.

C++

// C++ Program to find the number of islands using  // Space Optimized BFS  #include <bits/stdc++.h> using namespace std;  // A function to check if a given cell (r, c)  // can be included in BFS bool isSafe(vector<vector<char>>& grid, int r, int c) {     int rows = grid.size();     int cols = grid[0].size();     return (r >= 0) && (r < rows) && (c >= 0) &&           			(c < cols) && (grid[r][c] == 'L'); }  // Breadth-First-Search to visit all cells in the  // current island void bfs(vector<vector<char>>& grid, int sr, int sc) {        // These arrays are used to get row and     // column numbers of 8 neighbours of     // a given cell     vector<int> rNbr = { -1, -1, -1, 0, 0, 1, 1, 1 };     vector<int> cNbr = { -1, 0, 1, -1, 1, -1, 0, 1 };      // Simple BFS first step, we enqueue     // source and mark it as visited     queue<pair<int, int>> q;     q.push({sr, sc});   	grid[sr][sc] = 'W';      // Next step of BFS. We take out     // items one by one from queue and     // enqueue their unvisited adjacent     while (!q.empty()) {         int r = q.front().first;         int c = q.front().second;         q.pop();          // Go through all 8 adjacent         for (int k = 0; k < 8; k++) {             int newR = r + rNbr[k];             int newC = c + cNbr[k];             if (isSafe(grid, newR, newC)) {                 grid[newR][newC] = 'W';                 q.push({newR, newC});             }         }     } }  // This function returns the number of islands  // (connected components) in a graph int countIslands(vector<vector<char>>& grid) {        // Mark all cells as not visited     int rows = grid.size();     int cols = grid[0].size();      // Call BFS for every unvisited vertex     // Whenever we see an unvisited vertex,     // we increment res (number of islands) also.     int res = 0;     for (int r = 0; r < rows; r++) {         for (int c = 0; c < cols; c++) {             if (grid[r][c] == 'L') {                 bfs(grid, r, c);                 res++;             }         }     }      return res; }  int main() {     vector<vector<char>> grid = { { 'L', 'L', 'W', 'W', 'W' },             { 'W', 'L', 'W', 'W', 'L' },             { 'L', 'W', 'W', 'L', 'L' },             { 'W', 'W', 'W', 'W', 'W' },             { 'L', 'W', 'L', 'L', 'W' }};      cout << countIslands(grid);     return 0; }

Java

import java.util.LinkedList; import java.util.Queue;  class GfG {          // A function to check if a given cell (r, c) can be included in BFS     static boolean isSafe(char[][] grid, int r, int c) {         int rows = grid.length;         int cols = grid[0].length;         return (r >= 0) && (r < rows) && (c >= 0) &&                 (c < cols) && (grid[r][c] == 'L');     }      // Breadth-First-Search to visit all cells in the current island     static void bfs(char[][] grid, int sr, int sc) {         // These arrays are used to get row and column numbers of 8 neighbors         int[] rNbr = { -1, -1, -1, 0, 0, 1, 1, 1 };         int[] cNbr = { -1, 0, 1, -1, 1, -1, 0, 1 };          // Simple BFS first step, we enqueue source and mark it as visited         Queue<int[]> q = new LinkedList<>();         q.add(new int[] { sr, sc });         grid[sr][sc] = 'W'; // Mark as visited by changing 'L' to 'W'          // Process all items in the queue         while (!q.isEmpty()) {             int[] cell = q.poll();             int r = cell[0];             int c = cell[1];              // Explore all 8 adjacent cells             for (int k = 0; k < 8; k++) {                 int newR = r + rNbr[k];                 int newC = c + cNbr[k];                 if (isSafe(grid, newR, newC)) {                     grid[newR][newC] = 'W'; // Mark as visited                     q.add(new int[] { newR, newC });                 }             }         }     }      // This function returns the number of islands (connected components) in a grid     static int countIslands(char[][] grid) {         int rows = grid.length;         int cols = grid[0].length;         int islandCount = 0;                  for (int r = 0; r < rows; r++) {             for (int c = 0; c < cols; c++) {                 if (grid[r][c] == 'L') {                     bfs(grid, r, c);                     islandCount++;                 }             }         }          return islandCount;     }      public static void main(String[] args) {         char[][] grid = {             { 'L', 'L', 'W', 'W', 'W' },             { 'W', 'L', 'W', 'W', 'L' },             { 'L', 'W', 'W', 'L', 'L' },             { 'W', 'W', 'W', 'W', 'W' },             { 'L', 'W', 'L', 'L', 'W' }         };          System.out.println(countIslands(grid)); // Expected output: 4     } }

Python

from collections import deque  # A function to check if a given cell (r, c) can be included in BFS def isSafe(grid, r, c):     rows, cols = len(grid), len(grid[0])     return (0 <= r < rows) and (0 <= c < cols) and (grid[r][c] == 'L')  # Breadth-First-Search to visit all cells in the current island def bfs(grid, sr, sc):     # These arrays are used to get row and column numbers of 8 neighbors     rNbr = [-1, -1, -1, 0, 0, 1, 1, 1]     cNbr = [-1, 0, 1, -1, 1, -1, 0, 1]      # Simple BFS first step, enqueue source and mark it as visited     q = deque([(sr, sc)])     grid[sr][sc] = 'W'  # Mark as visited by changing 'L' to 'W'      # Process all items in the queue     while q:         r, c = q.popleft()          # Explore all 8 adjacent cells         for k in range(8):             newR, newC = r + rNbr[k], c + cNbr[k]             if isSafe(grid, newR, newC):                 grid[newR][newC] = 'W'  # Mark as visited                 q.append((newR, newC))  # This function returns the number of islands (connected components) in a grid def countIslands(grid):     rows, cols = len(grid), len(grid[0])     islandCount = 0          for r in range(rows):         for c in range(cols):             if grid[r][c] == 'L':                 bfs(grid, r, c)                 islandCount += 1      return islandCount  if __name__ == "__main__":     grid = [         ['L', 'L', 'W', 'W', 'W'],         ['W', 'L', 'W', 'W', 'L'],         ['L', 'W', 'W', 'L', 'L'],         ['W', 'W', 'W', 'W', 'W'],         ['L', 'W', 'L', 'L', 'W']     ]      print(countIslands(grid))

using System; using System.Collections.Generic;  class GfG {        // A function to check if a given cell (r, c) can be included in BFS     static bool IsSafe(char[][] grid, int r, int c) {         int rows = grid.Length;         int cols = grid[0].Length;         return (r >= 0) && (r < rows) && (c >= 0) &&                 (c < cols) && (grid[r][c] == 'L');     }      // Breadth-First-Search to visit all cells in the current island     static void bfs(char[][] grid, int sr, int sc) {                // These arrays are used to get row and column numbers of 8 neighbors         int[] rNbr = { -1, -1, -1, 0, 0, 1, 1, 1 };         int[] cNbr = { -1, 0, 1, -1, 1, -1, 0, 1 };          // BFS initialization: enqueue the source and mark it as visited         Queue<(int, int)> q = new Queue<(int, int)>();         q.Enqueue((sr, sc));         grid[sr][sc] = 'W';  // Mark as visited by changing 'L' to 'W'          // BFS traversal         while (q.Count > 0) {             var (r, c) = q.Dequeue();              // Explore all 8 adjacent cells             for (int k = 0; k < 8; k++) {                 int newR = r + rNbr[k];                 int newC = c + cNbr[k];                 if (IsSafe(grid, newR, newC)) {                     grid[newR][newC] = 'W';  // Mark as visited                     q.Enqueue((newR, newC));                 }             }         }     }      // This function returns the number of islands (connected components) in a grid     static int countIslands(char[][] grid) {         int rows = grid.Length;         int cols = grid[0].Length;         int res = 0;                  for (int r = 0; r < rows; r++) {             for (int c = 0; c < cols; c++) {                 if (grid[r][c] == 'L') {                     bfs(grid, r, c);                     res++;                 }             }         }          return res;     }      static void Main() {         char[][] grid = new char[][] {             new char[] { 'L', 'L', 'W', 'W', 'W' },             new char[] { 'W', 'L', 'W', 'W', 'L' },             new char[] { 'L', 'W', 'W', 'L', 'L' },             new char[] { 'W', 'W', 'W', 'W', 'W' },             new char[] { 'L', 'W', 'L', 'L', 'W' }         };          Console.WriteLine(countIslands(grid));  // Expected output: 4     } }

JavaScript

// A function to check if a given cell (r, c) can be included in BFS function isSafe(grid, r, c) {     const rows = grid.length;     const cols = grid[0].length;     return (r >= 0) && (r < rows) && (c >= 0) &&             (c < cols) && (grid[r][c] === 'L'); }  // Breadth-First-Search to visit all cells in the current island function bfs(grid, sr, sc) {     // These arrays are used to get row and column numbers of 8 neighbors     const rNbr = [-1, -1, -1, 0, 0, 1, 1, 1];     const cNbr = [-1, 0, 1, -1, 1, -1, 0, 1];      // BFS initialization: enqueue the source and mark it as visited     let queue = [[sr, sc]];     grid[sr][sc] = 'W'; // Mark as visited by changing 'L' to 'W'      // BFS traversal     while (queue.length > 0) {         const [r, c] = queue.shift();          // Explore all 8 adjacent cells         for (let k = 0; k < 8; k++) {             const newR = r + rNbr[k];             const newC = c + cNbr[k];             if (isSafe(grid, newR, newC)) {                 grid[newR][newC] = 'W'; // Mark as visited                 queue.push([newR, newC]);             }         }     } }  // This function returns the number of islands (connected components) in a grid function countIslands(grid) {     const rows = grid.length;     const cols = grid[0].length;     let res = 0;      for (let r = 0; r < rows; r++) {         for (let c = 0; c < cols; c++) {             if (grid[r][c] === 'L') {                 bfs(grid, r, c);                 res++;             }         }     }      return res; }  // Example usage const grid = [     ['L', 'L', 'W', 'W', 'W'],     ['W', 'L', 'W', 'W', 'L'],     ['L', 'W', 'W', 'L', 'L'],     ['W', 'W', 'W', 'W', 'W'],     ['L', 'W', 'L', 'L', 'W'] ];  console.log(countIslands(grid));  // Expected output: 4

Output

Print all shortest paths between given source and destination in an undirected graph

kartik

Improve

Article Tags :

Practice Tags :

Islands in a graph using BFS

Approach:- Using BFS and Additional Matrix - O(rows * cols) Time and O(rows * cols) Space

Space Optimized Approach:- Using Space Optimized BFS - O(rows * cols) Time and O(rows + cols) Space

Similar Reads

BFS in different language

Variations of BFS implementations

Easy problems on BFS

Intermediate problems on BFS

Hard Problems on BFS