Find length of the largest region in Boolean Matrix

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 
Ex: in the following example, there are 2 regions one with length 1 and the other as 6.
    so largest region : 6

Asked in : Amazon interview

Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

Idea is based on the problem or finding number of islands in Boolean 2D-matrix
A cell in 2D matrix can be connected to at most 8 neighbors. So in DFS, we make recursive calls for 8 neighbors. We keep track of the visited 1’s in every DFS and update maximum length region.

Below is implementation of above idea.

C++

// 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 DFS 
int 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 vertices 
void 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 matrix 
int  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 program to test above function 
int main() 
{ 
    int M[][COL] = { {0, 0, 1, 1, 0}, 
                     {1, 0, 1, 1, 0}, 
                     {0, 1, 0, 0, 0}, 
                     {0, 0, 0, 0, 1}}; 
  
    cout << largestRegion(M); 
  
    return 0; 
} 

Java

// Java program to find the length of the largest  
// region in boolean 2D-matrix  
import 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; 
        System.out.println(largestRegion(M)); 
} 
} 
  
// This code is contributed by rachana soma 

Python3

# 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 travesle  
    # 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 Code 
ROW = 4
COL = 5
  
M = [[0, 0, 1, 1, 0], 
     [1, 0, 1, 1, 0],  
     [0, 1, 0, 0, 0], 
     [0, 0, 0, 0, 1]]  
  
print(largestRegion(M)) 
  
# This code is contributed by PranchalK 

Output:

Time complexity: O(ROW x COL)

This article is contributed by Nishant Singh. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@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.

My Personal Notes

Suggest a Topic

Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

C++

Java

Python3

Recommended Posts: