# Count number of islands where every island is row-wise and column-wise separated

Given a rectangular matrix which has only two possible values ‘X’ and ‘O’. The values ‘X’ always appear in form of rectangular islands and these islands are always row-wise and column-wise separated by at least one line of ‘O’s. Note that islands can only be diagonally adjacent. Count the number of islands in the given matrix.

Examples:

`mat[M][N] =  {{'O', 'O', 'O'},              {'X', 'X', 'O'},              {'X', 'X', 'O'},              {'O', 'O', 'X'},              {'O', 'O', 'X'},              {'X', 'X', 'O'}             };Output: Number of islands is 3mat[M][N] =  {{'X', 'O', 'O', 'O', 'O', 'O'},              {'X', 'O', 'X', 'X', 'X', 'X'},              {'O', 'O', 'O', 'O', 'O', 'O'},              {'X', 'X', 'X', 'O', 'X', 'X'},              {'X', 'X', 'X', 'O', 'X', 'X'},              {'O', 'O', 'O', 'O', 'X', 'X'},             };Output: Number of islands is 4`

We strongly recommend to minimize your browser and try this yourself first.

The idea is to count all top-leftmost corners of given matrix. We can check if a ‘X’ is top left or not by checking following conditions.

1. A ‘X’ is top of rectangle if the cell just above it is a ‘O’
2. A ‘X’ is leftmost of rectangle if the cell just left of it is a ‘O’

Note that we must check for both conditions as there may be more than one top cells and more than one leftmost cells in a rectangular island. Below is the implementation of above idea.

## C++

 `// A C++ program to count the number of rectangular` `// islands where every island is separated by a line` `#include` `using` `namespace` `std;`   `// Size of given matrix is M X N` `#define M 6` `#define N 3`   `// This function takes a matrix of 'X' and 'O'` `// and returns the number of rectangular islands` `// of 'X' where no two islands are row-wise or` `// column-wise adjacent, the islands may be diagonally` `// adjacent` `int` `countIslands(``int` `mat[][N])` `{` `    ``int` `count = 0; ``// Initialize result`   `    ``// Traverse the input matrix` `    ``for` `(``int` `i=0; i

## Java

 `// A Java program to count the number of rectangular` `// islands where every island is separated by a line` `import` `java.io.*;`   `class` `islands ` `{` `    ``// This function takes a matrix of 'X' and 'O'` `    ``// and returns the number of rectangular islands` `    ``// of 'X' where no two islands are row-wise or` `    ``// column-wise adjacent, the islands may be diagonally` `    ``// adjacent` `    ``static` `int` `countIslands(``int` `mat[][], ``int` `m, ``int` `n)` `    ``{` `        ``// Initialize result` `        ``int` `count = ``0``; `   `        ``// Traverse the input matrix` `        ``for` `(``int` `i=``0``; i

## Python3

 `# A Python3 program to count the number ` `# of rectangular islands where every ` `# island is separated by a line`   `# Size of given matrix is M X N` `M ``=` `6` `N ``=` `3`   `# This function takes a matrix of 'X' and 'O'` `# and returns the number of rectangular ` `# islands of 'X' where no two islands are ` `# row-wise or column-wise adjacent, the islands ` `# may be diagonally adjacent` `def` `countIslands(mat):`   `    ``count ``=` `0``; ``# Initialize result`   `    ``# Traverse the input matrix` `    ``for` `i ``in` `range` `(``0``, M):` `    `  `        ``for` `j ``in` `range``(``0``, N):` `        `  `            ``# If current cell is 'X', then check` `            ``# whether this is top-leftmost of a` `            ``# rectangle. If yes, then increment count` `            ``if` `(mat[i][j] ``=``=` `'X'``):` `            `  `                ``if` `((i ``=``=` `0` `or` `mat[i ``-` `1``][j] ``=``=` `'O'``) ``and` `                    ``(j ``=``=` `0` `or` `mat[i][j ``-` `1``] ``=``=` `'O'``)):` `                    ``count ``=` `count ``+` `1` `            `  `    ``return` `count`   `# Driver Code` `mat ``=` `[[``'O'``, ``'O'``, ``'O'``],` `       ``[``'X'``, ``'X'``, ``'O'``],` `       ``[``'X'``, ``'X'``, ``'O'``],` `       ``[``'O'``, ``'O'``, ``'X'``],` `       ``[``'O'``, ``'O'``, ``'X'``],` `       ``[``'X'``, ``'X'``, ``'O'``]]` `                `  `print``(``"Number of rectangular islands is"``, ` `                       ``countIslands(mat))`   `# This code is contributed by iAyushRaj`

## C#

 `// A C# program to count the number of rectangular ` `// islands where every island is separated by ` `// a line` `using` `System;`   `class` `GFG {` `    `  `    ``// This function takes a matrix of 'X' and 'O'` `    ``// and returns the number of rectangular ` `    ``// islands of 'X' where no two islands are` `    ``// row-wise or column-wise adjacent, the` `    ``// islands may be diagonally adjacent` `    ``static` `int` `countIslands(``int` `[,]mat, ``int` `m, ``int` `n)` `    ``{` `        `  `        ``// Initialize result` `        ``int` `count = 0; `   `        ``// Traverse the input matrix` `        ``for` `(``int` `i = 0; i < m; i++)` `        ``{` `            ``for` `(``int` `j = 0; j < n; j++)` `            ``{` `                ``// If current cell is 'X', then check` `                ``// whether this is top-leftmost of a` `                ``// rectangle. If yes, then increment` `                ``// count` `                ``if` `(mat[i,j] == ``'X'``)` `                ``{` `                    ``if` `((i == 0 || mat[i-1,j] == ``'O'``) &&` `                        ``(j == 0 || mat[i,j-1] == ``'O'``))` `                        ``count++;` `                ``}` `            ``}` `        ``}`   `        ``return` `count;` `    ``}` `    `  `    ``// Driver program` `    ``public` `static` `void` `Main () ` `    ``{` `        `  `        ``// Size of given matrix is m X n` `        ``int` `m = 6;` `        ``int` `n = 3;` `        ``int` `[,]mat = { {``'O'``, ``'O'``, ``'O'``},` `                       ``{``'X'``, ``'X'``, ``'O'``},` `                       ``{``'X'``, ``'X'``, ``'O'``},` `                       ``{``'O'``, ``'O'``, ``'X'``},` `                       ``{``'O'``, ``'O'``, ``'X'``},` `                       ``{``'X'``, ``'X'``, ``'O'``}` `                    ``};` `        ``Console.WriteLine(``"Number of rectangular "` `         ``+ ``"islands is: "` `+ countIslands(mat, m, n));` `    ``}` `}`   `// This code is contributed by Sam007.`

## Javascript

 ``

## PHP

 ``

Output

```Number of rectangular islands is 3

```

Time complexity of this solution is O(M x N).
Auxiliary Space: O(1)

Approach 2:

To implement this using a dynamic programming (DP) approach, we need to modify the logic of counting islands. Instead of checking each cell individually, we’ll maintain a DP table to store the count of islands up to a particular cell.

Here’s the modified version of the program using a DP approach:

## C++

 `#include` `using` `namespace` `std;`   `// Size of given matrix is M X N` `#define M 6` `#define N 3`   `// This function takes a matrix of 'X' and 'O'` `// and returns the number of rectangular islands` `// of 'X' where no two islands are row-wise or` `// column-wise adjacent, the islands may be diagonally` `// adjacent` `int` `countIslands(``int` `mat[][N])` `{` `    ``int` `dp[M][N]; ``// DP table to store count of islands` `    ``int` `count = 0; ``// Initialize result`   `    ``// Traverse the input matrix` `    ``for` `(``int` `i = 0; i < M; i++)` `    ``{` `        ``for` `(``int` `j = 0; j < N; j++)` `        ``{` `            ``// If current cell is 'O', then no island can be formed` `            ``if` `(mat[i][j] == ``'O'``)` `                ``dp[i][j] = 0;` `            ``else` `            ``{` `                ``// If this is the first column or the cell above is 'O',` `                ``// then this cell is the top-leftmost of a rectangle` `                ``if` `(j == 0 || mat[i][j - 1] == ``'O'``)` `                    ``dp[i][j] = 1;` `                ``else` `                    ``dp[i][j] = dp[i][j - 1] + 1;`   `                ``// Increment count by the value in the DP table` `                ``count += dp[i][j];` `            ``}` `        ``}` `    ``}`   `    ``return` `count;` `}`   `// Driver program to test above function` `int` `main()` `{` `    ``int` `mat[M][N] =  {{``'O'``, ``'O'``, ``'O'``},` `                      ``{``'X'``, ``'X'``, ``'O'``},` `                      ``{``'X'``, ``'X'``, ``'O'``},` `                      ``{``'O'``, ``'O'``, ``'X'``},` `                      ``{``'O'``, ``'O'``, ``'X'``},` `                      ``{``'X'``, ``'X'``, ``'O'``}` `                    ``};` `    ``cout << ``"Number of rectangular islands is "` `         ``<< countIslands(mat);` `    ``return` `0;` `}`

## Java

 `import` `java.util.*;`   `public` `class` `Main {` `    ``// Size of given matrix is M X N` `    ``static` `final` `int` `M = ``6``;` `    ``static` `final` `int` `N = ``3``;`   `    ``// This function takes a matrix of 'X' and 'O'` `    ``// and returns the number of rectangular islands` `    ``// of 'X' where no two islands are row-wise or` `    ``// column-wise adjacent, the islands may be diagonally` `    ``// adjacent` `    ``static` `int` `countIslands(``char``[][] mat) {` `        ``int``[][] dp = ``new` `int``[M][N]; ``// DP table to store count of islands` `        ``int` `count = ``0``; ``// Initialize result`   `        ``// Traverse the input matrix` `        ``for` `(``int` `i = ``0``; i < M; i++) {` `            ``for` `(``int` `j = ``0``; j < N; j++) {` `                ``// If current cell is 'O', then no island can be formed` `                ``if` `(mat[i][j] == ``'O'``)` `                    ``dp[i][j] = ``0``;` `                ``else` `{` `                    ``// If this is the first column or the cell above is 'O',` `                    ``// then this cell is the top-leftmost of a rectangle` `                    ``if` `(j == ``0` `|| mat[i][j - ``1``] == ``'O'``)` `                        ``dp[i][j] = ``1``;` `                    ``else` `                        ``dp[i][j] = dp[i][j - ``1``] + ``1``;`   `                    ``// Increment count by the value in the DP table` `                    ``count += dp[i][j];` `                ``}` `            ``}` `        ``}`   `        ``return` `count;` `    ``}`   `    ``// Driver program to test above function` `    ``public` `static` `void` `main(String[] args) {` `        ``char``[][] mat = { ` `            ``{ ``'O'``, ``'O'``, ``'O'` `}, ` `            ``{ ``'X'``, ``'X'``, ``'O'` `}, ` `            ``{ ``'X'``, ``'X'``, ``'O'` `}, ` `            ``{ ``'O'``, ``'O'``, ``'X'` `},` `            ``{ ``'O'``, ``'O'``, ``'X'` `}, ` `            ``{ ``'X'``, ``'X'``, ``'O'` `} ` `        ``};` `        ``System.out.println(``"Number of rectangular islands is "` `+ countIslands(mat));` `    ``}` `}`

## Python3

 `# Size of given matrix is M X N` `M ``=` `6` `N ``=` `3`   `# This function takes a matrix of 'X' and 'O'` `# and returns the number of rectangular islands` `# of 'X' where no two islands are row-wise or` `# column-wise adjacent, the islands may be diagonally` `# adjacent` `def` `countIslands(mat):` `    ``dp ``=` `[[``0``] ``*` `N ``for` `_ ``in` `range``(M)]  ``# DP table to store count of islands` `    ``count ``=` `0`  `# Initialize result`   `    ``# Traverse the input matrix` `    ``for` `i ``in` `range``(M):` `        ``for` `j ``in` `range``(N):` `            ``# If current cell is 'O', then no island can be formed` `            ``if` `mat[i][j] ``=``=` `'O'``:` `                ``dp[i][j] ``=` `0` `            ``else``:` `                ``# If this is the first column or the cell above is 'O',` `                ``# then this cell is the top-leftmost of a rectangle` `                ``if` `j ``=``=` `0` `or` `mat[i][j ``-` `1``] ``=``=` `'O'``:` `                    ``dp[i][j] ``=` `1` `                ``else``:` `                    ``dp[i][j] ``=` `dp[i][j ``-` `1``] ``+` `1`   `                ``# Increment count by the value in the DP table` `                ``count ``+``=` `dp[i][j]`   `    ``return` `count`   `# Driver program to test above function` `if` `__name__ ``=``=` `"__main__"``:` `    ``mat ``=` `[[``'O'``, ``'O'``, ``'O'``],` `           ``[``'X'``, ``'X'``, ``'O'``],` `           ``[``'X'``, ``'X'``, ``'O'``],` `           ``[``'O'``, ``'O'``, ``'X'``],` `           ``[``'O'``, ``'O'``, ``'X'``],` `           ``[``'X'``, ``'X'``, ``'O'``]]` `    `  `    ``print``(``"Number of rectangular islands is"``, countIslands(mat))`   `# This code is contributed by Shivam Tiwari`

## C#

 `using` `System;`   `public` `class` `GFG` `{` `    ``// Size of given matrix is M X N` `    ``const` `int` `M = 6;` `    ``const` `int` `N = 3;`   `    ``// This function takes a matrix of 'X' and 'O'` `    ``// and returns the number of rectangular islands` `    ``// of 'X' where no two islands are row-wise or` `    ``// column-wise adjacent, the islands may be diagonally` `    ``// adjacent` `    ``static` `int` `CountIslands(``char``[][] mat)` `    ``{` `        ``int``[][] dp = ``new` `int``[M][];` `        ``for` `(``int` `i = 0; i < M; i++)` `        ``{` `            ``dp[i] = ``new` `int``[N];` `        ``}`   `        ``int` `count = 0; ``// Initialize result`   `        ``// Traverse the input matrix` `        ``for` `(``int` `i = 0; i < M; i++)` `        ``{` `            ``for` `(``int` `j = 0; j < N; j++)` `            ``{` `                ``// If current cell is 'O', then no island can be formed` `                ``if` `(mat[i][j] == ``'O'``)` `                    ``dp[i][j] = 0;` `                ``else` `                ``{` `                    ``// If this is the first column or the cell above is 'O',` `                    ``// then this cell is the top-leftmost of a rectangle` `                    ``if` `(j == 0 || mat[i][j - 1] == ``'O'``)` `                        ``dp[i][j] = 1;` `                    ``else` `                        ``dp[i][j] = dp[i][j - 1] + 1;`   `                    ``// Increment count by the value in the DP table` `                    ``count += dp[i][j];` `                ``}` `            ``}` `        ``}`   `        ``return` `count;` `    ``}`   `    ``// Driver program to test above function` `    ``static` `void` `Main()` `    ``{` `        ``char``[][] mat = ``new` `char``[][] {` `            ``new` `char``[] { ``'O'``, ``'O'``, ``'O'` `},` `            ``new` `char``[] { ``'X'``, ``'X'``, ``'O'` `},` `            ``new` `char``[] { ``'X'``, ``'X'``, ``'O'` `},` `            ``new` `char``[] { ``'O'``, ``'O'``, ``'X'` `},` `            ``new` `char``[] { ``'O'``, ``'O'``, ``'X'` `},` `            ``new` `char``[] { ``'X'``, ``'X'``, ``'O'` `}` `        ``};`   `        ``Console.WriteLine(``"Number of rectangular islands is "` `+ CountIslands(mat));`   `        ``// This code is contributed by Shivam Tiwari` `    ``}` `}`

## Javascript

 `// Size of given matrix is M X N` `const M = 6;` `const N = 3;`   `// This function takes a matrix of 'X' and 'O'` `// and returns the number of rectangular islands` `// of 'X' where no two islands are row-wise or` `// column-wise adjacent, the islands may be diagonally` `// adjacent` `function` `countIslands(mat) {` `    ``const dp = ``new` `Array(M).fill(0).map(() => ``new` `Array(N).fill(0));` `    ``let count = 0;`   `    ``// Traverse the input matrix` `    ``for` `(let i = 0; i < M; i++) {` `        ``for` `(let j = 0; j < N; j++) {` `            ``// If current cell is 'O', then no island can be formed` `            ``if` `(mat[i][j] === ``'O'``)` `                ``dp[i][j] = 0;` `            ``else` `{` `                ``// If this is the first column or the cell above is 'O',` `                ``// then this cell is the top-leftmost of a rectangle` `                ``if` `(j === 0 || mat[i][j - 1] === ``'O'``)` `                    ``dp[i][j] = 1;` `                ``else` `                    ``dp[i][j] = dp[i][j - 1] + 1;`   `                ``// Increment count by the value in the DP table` `                ``count += dp[i][j];` `            ``}` `        ``}` `    ``}`   `    ``return` `count;` `}`   `// Driver program to test above function` `const mat = [` `    ``[``'O'``, ``'O'``, ``'O'``],` `    ``[``'X'``, ``'X'``, ``'O'``],` `    ``[``'X'``, ``'X'``, ``'O'``],` `    ``[``'O'``, ``'O'``, ``'X'``],` `    ``[``'O'``, ``'O'``, ``'X'``],` `    ``[``'X'``, ``'X'``, ``'O'``]` `];`   `console.log(``"Number of rectangular islands is "` `+ countIslands(mat));`

Output

```Number of rectangular islands is 11

```

Time complexity of this solution is O(M x N).
Auxiliary Space: O(1)

If you like GeeksforGeeks and would like to contribute, you can also write an article and mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next