Find length of the largest region in Boolean Matrix - GeeksforGeeks

09 Mar, 2022
Consider a matrix with rows and columns, where each cell contains either a ‘0’ or a ‘1’ and any cell containing a 1 is called a filled cell. Two cells are said to be connected if they are adjacent to each other horizontally, vertically, or diagonally. If one or more filled cells are also connected, they form a region. find the length of the largest region.
Examples: 
Input : M[][5] = { 0 0 1 1 0
                   1 0 1 1 0
                   0 1 0 0 0
                   0 0 0 0 1 }
Output : 6 
In the following example, there are 
2 regions one with length 1 and the 
other as 6. So largest region: 6

Input : M[][5] = { 0 0 1 1 0
                   0 0 1 1 0
                   0 0 0 0 0
                   0 0 0 0 1 }
Output: 4
In the following example, there are 
2 regions one with length 1 and the 
other as 4. So largest region: 4
Asked in: Amazon interview 
Solution: The idea is based on the problem or finding number of islands in Boolean 2D-matrix 
Approach:  
A cell in 2D matrix can be connected to at most 8 neighbours.So in DFS, make recursive calls for 8 neighbours of that cell.Keep a visited Hash-map to keep track of all visited cells.Also keep track of the visited 1’s in every DFS and update maximum length region.
A cell in 2D matrix can be connected to at most 8 neighbours.
So in DFS, make recursive calls for 8 neighbours of that cell.
Keep a visited Hash-map to keep track of all visited cells.
Also keep track of the visited 1’s in every DFS and update maximum length region.
Below is implementation of above idea. 
C++
Java
Python3
C#
Javascript
// Program to find the length of the largest// region in boolean 2D-matrix#include <bits/stdc++.h>using namespace std;#define ROW 4#define COL 5 // A function to check if// a given cell (row, col)// can be included in DFSint isSafe(int M[][COL], int row, int col,           bool visited[][COL]){    // row number is in range,    // column number is in    // range and value is 1    // and not yet visited    return (row >= 0) && (row < ROW) && (col >= 0)           && (col < COL)           && (M[row][col] && !visited[row][col]);} // A utility function to// do DFS for a 2D boolean// matrix. It only considers// the 8 neighbours as// adjacent verticesvoid DFS(int M[][COL], int row, int col,         bool visited[][COL], int& count){    // These arrays are used    // to get row and column    // numbers of 8 neighbours    // of a given cell    static int rowNbr[] = { -1, -1, -1, 0, 0, 1, 1, 1 };    static int colNbr[] = { -1, 0, 1, -1, 1, -1, 0, 1 };     // Mark this cell as visited    visited[row][col] = true;     // Recur for all connected neighbours    for (int k = 0; k < 8; ++k)    {        if (isSafe(M, row + rowNbr[k],                   col + colNbr[k],                   visited))        {            // Increment region length by one            count++;            DFS(M, row + rowNbr[k], col + colNbr[k],                visited, count);        }    }} // The main function that returns// largest  length region// of a given boolean 2D matrixint largestRegion(int M[][COL]){    // Make a bool array to mark visited cells.    // Initially all cells are unvisited    bool visited[ROW][COL];    memset(visited, 0, sizeof(visited));     // Initialize result as 0 and travesle through the    // all cells of given matrix    int result = INT_MIN;    for (int i = 0; i < ROW; ++i)    {        for (int j = 0; j < COL; ++j)        {            // If a cell with value 1 is not            if (M[i][j] && !visited[i][j])            {                // visited yet, then new region found                int count = 1;                DFS(M, i, j, visited, count);                 // maximum region                result = max(result, count);            }        }    }    return result;} // Driver codeint main(){    int M[][COL] = { { 0, 0, 1, 1, 0 },                     { 1, 0, 1, 1, 0 },                     { 0, 1, 0, 0, 0 },                     { 0, 0, 0, 0, 1 } };     // Function call    cout << largestRegion(M);     return 0;}
// Java program to find the length of the largest// region in boolean 2D-matriximport java.io.*;import java.util.*; class GFG {    static int ROW, COL, count;     // A function to check if a given cell (row, col)    // can be included in DFS    static boolean isSafe(int[][] M, int row, int col,                          boolean[][] visited)    {        // row number is in range, column number is in        // range and value is 1 and not yet visited        return (            (row >= 0) && (row < ROW) && (col >= 0)            && (col < COL)            && (M[row][col] == 1 && !visited[row][col]));    }     // A utility function to do DFS for a 2D boolean    // matrix. It only considers the 8 neighbours as    // adjacent vertices    static void DFS(int[][] M, int row, int col,                    boolean[][] visited)    {        // These arrays are used to get row and column        // numbers of 8 neighbours of a given cell        int[] rowNbr = { -1, -1, -1, 0, 0, 1, 1, 1 };        int[] colNbr = { -1, 0, 1, -1, 1, -1, 0, 1 };         // Mark this cell as visited        visited[row][col] = true;         // Recur for all connected neighbours        for (int k = 0; k < 8; k++)        {            if (isSafe(M, row + rowNbr[k], col + colNbr[k],                       visited))            {                // increment region length by one                count++;                DFS(M, row + rowNbr[k], col + colNbr[k],                    visited);            }        }    }     // The main function that returns largest length region    // of a given boolean 2D matrix    static int largestRegion(int[][] M)    {        // Make a boolean array to mark visited cells.        // Initially all cells are unvisited        boolean[][] visited = new boolean[ROW][COL];         // Initialize result as 0 and traverse through the        // all cells of given matrix        int result = 0;        for (int i = 0; i < ROW; i++)        {            for (int j = 0; j < COL; j++)            {                 // If a cell with value 1 is not                if (M[i][j] == 1 && !visited[i][j])                {                     // visited yet, then new region found                    count = 1;                    DFS(M, i, j, visited);                     // maximum region                    result = Math.max(result, count);                }            }        }        return result;    }     // Driver code    public static void main(String args[])    {        int M[][] = { { 0, 0, 1, 1, 0 },                      { 1, 0, 1, 1, 0 },                      { 0, 1, 0, 0, 0 },                      { 0, 0, 0, 0, 1 } };        ROW = 4;        COL = 5;               // Function call        System.out.println(largestRegion(M));    }} // This code is contributed by rachana soma
# Python3 program to find the length of the# largest region in boolean 2D-matrix # A function to check if a given cell# (row, col) can be included in DFS  def isSafe(M, row, col, visited):    global ROW, COL     # row number is in range, column number is in    # range and value is 1 and not yet visited    return ((row >= 0) and (row < ROW) and            (col >= 0) and (col < COL) and            (M[row][col] and not visited[row][col])) # A utility function to do DFS for a 2D# boolean matrix. It only considers# the 8 neighbours as adjacent vertices  def DFS(M, row, col, visited, count):     # These arrays are used to get row and column    # numbers of 8 neighbours of a given cell    rowNbr = [-1, -1, -1, 0, 0, 1, 1, 1]    colNbr = [-1, 0, 1, -1, 1, -1, 0, 1]     # Mark this cell as visited    visited[row][col] = True     # Recur for all connected neighbours    for k in range(8):        if (isSafe(M, row + rowNbr[k],                   col + colNbr[k], visited)):             # increment region length by one            count[0] += 1            DFS(M, row + rowNbr[k],                col + colNbr[k], visited, count) # The main function that returns largest# length region of a given boolean 2D matrix  def largestRegion(M):    global ROW, COL     # Make a bool array to mark visited cells.    # Initially all cells are unvisited    visited = [[0] * COL for i in range(ROW)]     # Initialize result as 0 and traverse    # through the all cells of given matrix    result = -999999999999    for i in range(ROW):        for j in range(COL):             # If a cell with value 1 is not            if (M[i][j] and not visited[i][j]):                 # visited yet, then new region found                count = [1]                DFS(M, i, j, visited, count)                 # maximum region                result = max(result, count[0])    return result  # Driver CodeROW = 4COL = 5 M = [[0, 0, 1, 1, 0],     [1, 0, 1, 1, 0],     [0, 1, 0, 0, 0],     [0, 0, 0, 0, 1]] # Function callprint(largestRegion(M)) # This code is contributed by PranchalK
// C# program to find the length of// the largest region in boolean 2D-matrixusing System; class GFG{    static int ROW, COL, count;     // A function to check if a given cell    // (row, col) can be included in DFS    static Boolean isSafe(int[, ] M, int row, int col,                          Boolean[, ] visited)    {        // row number is in range, column number is in        // range and value is 1 and not yet visited        return (            (row >= 0) && (row < ROW) && (col >= 0)            && (col < COL)            && (M[row, col] == 1 && !visited[row, col]));    }     // A utility function to do DFS for a 2D boolean    // matrix. It only considers the 8 neighbours as    // adjacent vertices    static void DFS(int[, ] M, int row, int col,                    Boolean[, ] visited)    {        // These arrays are used to get row and column        // numbers of 8 neighbours of a given cell        int[] rowNbr = { -1, -1, -1, 0, 0, 1, 1, 1 };        int[] colNbr = { -1, 0, 1, -1, 1, -1, 0, 1 };         // Mark this cell as visited        visited[row, col] = true;         // Recur for all connected neighbours        for (int k = 0; k < 8; k++)        {            if (isSafe(M, row + rowNbr[k],                       col + colNbr[k],                       visited))            {                // increment region length by one                count++;                DFS(M, row + rowNbr[k], col + colNbr[k],                    visited);            }        }    }     // The main function that returns    // largest length region of    // a given boolean 2D matrix    static int largestRegion(int[, ] M)    {        // Make a boolean array to mark visited cells.        // Initially all cells are unvisited        Boolean[, ] visited = new Boolean[ROW, COL];         // Initialize result as 0 and traverse        // through the all cells of given matrix        int result = 0;        for (int i = 0; i < ROW; i++)        {            for (int j = 0; j < COL; j++)            {                // If a cell with value 1 is not                if (M[i, j] == 1 && !visited[i, j])                {                    // visited yet,                    // then new region found                    count = 1;                    DFS(M, i, j, visited);                     // maximum region                    result = Math.Max(result, count);                }            }        }        return result;    }     // Driver code    public static void Main(String[] args)    {        int[, ] M = { { 0, 0, 1, 1, 0 },                      { 1, 0, 1, 1, 0 },                      { 0, 1, 0, 0, 0 },                      { 0, 0, 0, 0, 1 } };        ROW = 4;        COL = 5;               // Function call        Console.WriteLine(largestRegion(M));    }} // This code is contributed by Rajput-Ji
<script> // JavaScript program to find the length of the largest// region in boolean 2D-matrix let ROW, COL, count; // A function to check if a given cell (row, col)    // can be included in DFSfunction isSafe(M,row,col,visited){    // row number is in range, column number is in        // range and value is 1 and not yet visited        return (            (row >= 0) && (row < ROW) && (col >= 0)            && (col < COL)            && (M[row][col] == 1 && !visited[row][col]));} // A utility function to do DFS for a 2D boolean    // matrix. It only considers the 8 neighbours as    // adjacent verticesfunction DFS(M,row,col,visited){    // These arrays are used to get row and column        // numbers of 8 neighbours of a given cell        let rowNbr = [ -1, -1, -1, 0, 0, 1, 1, 1 ];        let colNbr = [ -1, 0, 1, -1, 1, -1, 0, 1 ];          // Mark this cell as visited        visited[row][col] = true;          // Recur for all connected neighbours        for (let k = 0; k < 8; k++)        {            if (isSafe(M, row + rowNbr[k], col + colNbr[k],                       visited))            {                // increment region length by one                count++;                DFS(M, row + rowNbr[k], col + colNbr[k],                    visited);            }        }} // The main function that returns largest length region    // of a given boolean 2D matrixfunction largestRegion(M){    // Make a boolean array to mark visited cells.        // Initially all cells are unvisited        let visited = new Array(ROW);         for(let i=0;i<ROW;i++)        {            visited[i]=new Array(COL);            for(let j=0;j<COL;j++)            {                visited[i][j]=false;            }        }                          // Initialize result as 0 and traverse through the        // all cells of given matrix        let result = 0;        for (let i = 0; i < ROW; i++)        {            for (let j = 0; j < COL; j++)            {                  // If a cell with value 1 is not                if (M[i][j] == 1 && !visited[i][j])                {                      // visited yet, then new region found                    count = 1;                    DFS(M, i, j, visited);                      // maximum region                    result = Math.max(result, count);                }            }        }        return result;} // Driver codelet M=[[ 0, 0, 1, 1, 0 ],                      [ 1, 0, 1, 1, 0 ],                      [ 0, 1, 0, 0, 0 ],                      [ 0, 0, 0, 0, 1 ] ];                       ROW = 4;COL = 5; // Function calldocument.write(largestRegion(M));  // This code is contributed by avanitrachhadiya2155 </script>
6
Complexity Analysis: 
Time complexity: O(ROW * COL). At worst case all the cells will be visited so time complexity is O(ROW * COL).
Auxiliary Space:O(ROW * COL). To store the visited nodes O(ROW * COL) space is needed.
This article is contributed by Nishant Singh. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
naba09
PranchalKatiyar
rachana soma
Rajput-Ji
andrew1234
nandalamit1555
avanitrachhadiya2155
surinderdawra388
Amazon
BFS
DFS
Microsoft
Samsung
Graph
Amazon
Microsoft
Samsung
DFS
Graph
BFS
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Topological Sorting
Detect Cycle in a Directed Graph
Travelling Salesman Problem | Set 1 (Naive and Dynamic Programming)
Ford-Fulkerson Algorithm for Maximum Flow Problem
Disjoint Set (Or Union-Find) | Set 1 (Detect Cycle in an Undirected Graph)
Traveling Salesman Problem (TSP) Implementation
Detect cycle in an undirected graph
Hamiltonian Cycle | Backtracking-6
m Coloring Problem | Backtracking-5
Dijkstra’s Algorithm for Adjacency List Representation | Greedy Algo-8