# 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[] = { 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
```

## 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 ` `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 `

## C#

 `// C# program to find the length of  ` `// the largest region in boolean 2D-matrix  ` `using` `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; ` `    ``Console.WriteLine(largestRegion(M)); ` `} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

Output:

```6
```

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.