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

Previous
Next