Islands in a graph using BFS

06 Jul, 2021
Given a boolean 2D matrix, find the number of islands. A group of connected 1s forms an island. For example, the below matrix contains 5 islands
Example:  
Input : mat[][] = {{1, 1, 0, 0, 0},
                   {0, 1, 0, 0, 1},
                   {1, 0, 0, 1, 1},
                   {0, 0, 0, 0, 0},
                   {1, 0, 1, 0, 1} 
Output : 5
What is an island? A group of connected 1s forms an island. For example, the below matrix contains 5 islands 
                        {1,  1, 0, 0, 0},
                        {0, 1, 0, 0, 1},
                        {1, 0, 0, 1, 1},
                        {0, 0, 0, 0, 0},
                        {1, 0, 1, 0, 1}
This is a variation of the standard problem: connected component. A connected component of an undirected graph is a subgraph in which every two vertices are connected to each other by a path(s), and which is connected to no other vertices outside the subgraph. 
For example, the graph shown below has three connected components.  
 
A graph where all vertices are connected with each other has exactly one connected component, consisting of the whole graph. Such graph with only one connected component is called as Strongly Connected Graph.We have discussed a DFS solution for islands is already discussed. This problem can also solved by applying BFS() on each component. In each BFS() call, a component or a sub-graph is visited. We will call BFS on the next un-visited component. The number of calls to BFS() gives the number of connected components. BFS can also be used.
A cell in 2D matrix can be connected to 8 neighbours. So, unlike standard BFS(), where we process all adjacent vertices, we process 8 neighbours only. We keep track of the visited 1s so that they are not visited again. 
C++
Java
Python3
C#
Javascript
// A BFS based solution to count number of// islands in a graph.#include <bits/stdc++.h>using namespace std; // R x C matrix#define R 5#define C 5 // A function to check if a given cell// (u, v) can be included in DFSbool isSafe(int mat[R][C], int i, int j,            bool vis[R][C]){    return (i >= 0) && (i < R) &&           (j >= 0) && (j < C) &&           (mat[i][j] && !vis[i][j]);} void BFS(int mat[R][C], bool vis[R][C],         int si, int sj){     // These arrays are used to get row and    // column numbers of 8 neighbours of    // a given cell    int row[] = { -1, -1, -1, 0, 0, 1, 1, 1 };    int col[] = { -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(make_pair(si, sj));    vis[si][sj] = true;     // Next step of BFS. We take out    // items one by one from queue and    // enqueue their univisited adjacent    while (!q.empty()) {         int i = q.front().first;        int j = q.front().second;        q.pop();         // Go through all 8 adjacent        for (int k = 0; k < 8; k++) {            if (isSafe(mat, i + row[k],                       j + col[k], vis)) {             vis[i + row[k]][j + col[k]] = true;             q.push(make_pair(i + row[k], j + col[k]));            }        }    }} // This function returns number islands (connected// components) in a graph. It simply works as// BFS for disconnected graph and returns count// of BFS calls.int countIslands(int mat[R][C]){    // Mark all cells as not visited    bool vis[R][C];    memset(vis, 0, sizeof(vis));     // Call BFS for every unvisited vertex    // Whenever we see an univisted vertex,    // we increment res (number of islands)    // also.    int res = 0;    for (int i = 0; i < R; i++) {        for (int j = 0; j < C; j++) {            if (mat[i][j] && !vis[i][j]) {                BFS(mat, vis, i, j);                res++;            }        }    }     return res;} // main functionint main(){    int mat[][C] = { { 1, 1, 0, 0, 0 },                     { 0, 1, 0, 0, 1 },                     { 1, 0, 0, 1, 1 },                     { 0, 0, 0, 0, 0 },                     { 1, 0, 1, 0, 1 } };     cout << countIslands(mat);     return 0;}
// A BFS based solution to count number of// islands in a graph.import java.util.*; class GFG{ // R x C matrixstatic final int R = 5;static final int C = 5 ;static class pair{    int first, second;    public pair(int first, int second)    {        this.first = first;        this.second = second;    }} // A function to check if a given cell// (u, v) can be included in DFSstatic boolean isSafe(int mat[][], int i, int j,                       boolean vis[][]){    return (i >= 0) && (i < R) &&        (j >= 0) && (j < C) &&        (mat[i][j]==1 && !vis[i][j]);} static void BFS(int mat[][], boolean vis[][],                int si, int sj){     // These arrays are used to get row and    // column numbers of 8 neighbours of    // a given cell    int row[] = { -1, -1, -1, 0, 0, 1, 1, 1 };    int col[] = { -1, 0, 1, -1, 1, -1, 0, 1 };     // Simple BFS first step, we enqueue    // source and mark it as visited    Queue<pair> q = new LinkedList<pair>();    q.add(new pair(si, sj));    vis[si][sj] = true;     // Next step of BFS. We take out    // items one by one from queue and    // enqueue their univisited adjacent    while (!q.isEmpty())    {         int i = q.peek().first;        int j = q.peek().second;        q.remove();         // Go through all 8 adjacent        for (int k = 0; k < 8; k++)        {            if (isSafe(mat, i + row[k],                    j + col[k], vis))            {                vis[i + row[k]][j + col[k]] = true;                q.add(new pair(i + row[k], j + col[k]));            }        }    }} // This function returns number islands (connected// components) in a graph. It simply works as// BFS for disconnected graph and returns count// of BFS calls.static int countIslands(int mat[][]){    // Mark all cells as not visited    boolean [][]vis = new boolean[R][C];     // Call BFS for every unvisited vertex    // Whenever we see an univisted vertex,    // we increment res (number of islands)    // also.    int res = 0;    for (int i = 0; i < R; i++)    {        for (int j = 0; j < C; j++)        {            if (mat[i][j]==1 && !vis[i][j])            {                BFS(mat, vis, i, j);                res++;            }        }    }    return res;} // Driver codepublic static void main(String[] args){    int mat[][] = { { 1, 1, 0, 0, 0 },                    { 0, 1, 0, 0, 1 },                    { 1, 0, 0, 1, 1 },                    { 0, 0, 0, 0, 0 },                    { 1, 0, 1, 0, 1 } };     System.out.print(countIslands(mat));}} // This code is contributed by PrinciRaj1992
# A BFS based solution to count number of# islands in a graph.from collections import deque # A function to check if a given cell# (u, v) can be included in DFSdef isSafe(mat, i, j, vis):         return ((i >= 0) and (i < 5) and             (j >= 0) and (j < 5) and          (mat[i][j] and (not vis[i][j]))) def BFS(mat, vis, si, sj):         # These arrays are used to get row and    # column numbers of 8 neighbours of    # a given cell    row = [-1, -1, -1, 0, 0, 1, 1, 1]    col = [-1, 0, 1, -1, 1, -1, 0, 1]     # Simple BFS first step, we enqueue    # source and mark it as visited    q = deque()    q.append([si, sj])    vis[si][sj] = True     # Next step of BFS. We take out    # items one by one from queue and    # enqueue their univisited adjacent    while (len(q) > 0):        temp = q.popleft()         i = temp[0]        j = temp[1]         # Go through all 8 adjacent        for k in range(8):            if (isSafe(mat, i + row[k], j + col[k], vis)):                vis[i + row[k]][j + col[k]] = True                q.append([i + row[k], j + col[k]]) # This function returns number islands (connected# components) in a graph. It simply works as# BFS for disconnected graph and returns count# of BFS calls.def countIslands(mat):          # Mark all cells as not visited    vis = [[False for i in range(5)]                  for i in range(5)]    # memset(vis, 0, sizeof(vis));     # 5all BFS for every unvisited vertex    # Whenever we see an univisted vertex,    # we increment res (number of islands)    # also.    res = 0     for i in range(5):        for j in range(5):            if (mat[i][j] and not vis[i][j]):                BFS(mat, vis, i, j)                res += 1     return res # Driver codeif __name__ == '__main__':         mat = [ [ 1, 1, 0, 0, 0 ],            [ 0, 1, 0, 0, 1 ],            [ 1, 0, 0, 1, 1 ],            [ 0, 0, 0, 0, 0 ],            [ 1, 0, 1, 0, 1 ]]     print (countIslands(mat)) # This code is contributed by mohit kumar 29
// A BFS based solution to count number of// islands in a graph.using System;using System.Collections.Generic; class GFG{ // R x C matrixstatic readonly int R = 5;static readonly int C = 5 ;class pair{    public int first, second;    public pair(int first, int second)    {        this.first = first;        this.second = second;    }} // A function to check if a given cell// (u, v) can be included in DFSstatic bool isSafe(int [,]mat, int i, int j,                    bool [,]vis){    return (i >= 0) && (i < R) &&        (j >= 0) && (j < C) &&        (mat[i, j]==1 && !vis[i, j]);} static void BFS(int [,]mat, bool [,]vis,                int si, int sj){     // These arrays are used to get row and    // column numbers of 8 neighbours of    // a given cell    int []row = { -1, -1, -1, 0, 0, 1, 1, 1 };    int []col = { -1, 0, 1, -1, 1, -1, 0, 1 };     // Simple BFS first step, we enqueue    // source and mark it as visited    List<pair> q = new List<pair>();    q.Add(new pair(si, sj));    vis[si, sj] = true;     // Next step of BFS. We take out    // items one by one from queue and    // enqueue their univisited adjacent    while (q.Count != 0)    {        int i = q[0].first;        int j = q[0].second;        q.RemoveAt(0);         // Go through all 8 adjacent        for (int k = 0; k < 8; k++)        {            if (isSafe(mat, i + row[k],                    j + col[k], vis))            {                vis[i + row[k], j + col[k]] = true;                q.Add(new pair(i + row[k], j + col[k]));            }        }    }} // This function returns number islands (connected// components) in a graph. It simply works as// BFS for disconnected graph and returns count// of BFS calls.static int countIslands(int [,]mat){    // Mark all cells as not visited    bool [,]vis = new bool[R, C];     // Call BFS for every unvisited vertex    // Whenever we see an univisted vertex,    // we increment res (number of islands)    // also.    int res = 0;    for (int i = 0; i < R; i++)    {        for (int j = 0; j < C; j++)        {            if (mat[i, j]==1 && !vis[i, j])            {                BFS(mat, vis, i, j);                res++;            }        }    }    return res;} // Driver codepublic static void Main(String[] args){    int [,]mat = { { 1, 1, 0, 0, 0 },                    { 0, 1, 0, 0, 1 },                    { 1, 0, 0, 1, 1 },                    { 0, 0, 0, 0, 0 },                    { 1, 0, 1, 0, 1 } };     Console.Write(countIslands(mat));}} // This code is contributed by 29AjayKumar
<script>// A BFS based solution to count number of// islands in a graph. // R x C matrixlet R = 5;let C = 5 ; // A function to check if a given cell// (u, v) can be included in DFSfunction isSafe(mat,i,j,vis){    return (i >= 0) && (i < R) &&        (j >= 0) && (j < C) &&        (mat[i][j] == 1 && !vis[i][j]);} function BFS(mat, vis, si, sj){     // These arrays are used to get row and    // column numbers of 8 neighbours of    // a given cell       let row = [ -1, -1, -1, 0, 0, 1, 1, 1 ];    let col = [ -1, 0, 1, -1, 1, -1, 0, 1 ];      // Simple BFS first step, we enqueue    // source and mark it as visited    let q = [];    q.push([si, sj]);    vis[si][sj] = true;      // Next step of BFS. We take out    // items one by one from queue and    // enqueue their univisited adjacent    while (q.length != 0)    {          let i = q[0][0];        let j = q[0][1];        q.shift();          // Go through all 8 adjacent        for (let k = 0; k < 8; k++)        {            if (isSafe(mat, i + row[k],                    j + col[k], vis))            {                vis[i + row[k]][j + col[k]] = true;                q.push([i + row[k], j + col[k]]);            }        }    }} // This function returns number islands (connected// components) in a graph. It simply works as// BFS for disconnected graph and returns count// of BFS calls.function countIslands(mat){     // Mark all cells as not visited    let vis = new Array(R);    for(let i = 0; i < R; i++)    {        vis[i] = new Array(C);        for(let j = 0; j < C; j++)        {            vis[i][j] = false;        }    }      // Call BFS for every unvisited vertex    // Whenever we see an univisted vertex,    // we increment res (number of islands)    // also.    let res = 0;    for (let i = 0; i < R; i++)    {        for (let j = 0; j < C; j++)        {            if (mat[i][j] == 1 && !vis[i][j])            {                BFS(mat, vis, i, j);                res++;            }        }    }    return res;} // Driver codelet mat = [[ 1, 1, 0, 0, 0 ],                    [ 0, 1, 0, 0, 1 ],                    [ 1, 0, 0, 1, 1 ],                    [ 0, 0, 0, 0, 0 ],                    [ 1, 0, 1, 0, 1 ] ];                     document.write(countIslands(mat)); // This code is contributed by patel2127.</script>
5
 
Time Complexity : O(ROW * COL) where ROW is number of ROWS and COL is number of COLUMNS in the matrix. 
princiraj1992
29AjayKumar
mohit kumar 29
patel2127
pk1409
BFS
Graph
Graph
BFS
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Find if there is a path between two vertices in a directed graph
Topological Sorting
Detect Cycle in a Directed Graph
Find if there is a path between two vertices in an undirected graph
Introduction to Data Structures
Disjoint Set (Or Union-Find) | Set 1 (Detect Cycle in an Undirected Graph)
What is Data Structure: Types, Classifications and Applications
Travelling Salesman Problem | Set 1 (Naive and Dynamic Programming)
Detect cycle in an undirected graph
Minimum number of swaps required to sort an array