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 3
mat[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.
- A ‘X’ is top of rectangle if the cell just above it is a ‘O’
- 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.
// A C++ program to count the number of rectangular // islands where every island is separated by a line #include<iostream> 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<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 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;
} |
// 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<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 (String[] args)
{
// 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' }
};
System.out.println( "Number of rectangular islands is: "
+ countIslands(mat, m, n));
}
} // This code is contributed by Pramod Kumar |
# 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 |
// 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. |
<script> // A Javascript program to count the number of rectangular
// islands where every island is separated by a line
// 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, m, n)
{
// Initialize result
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 '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;
}
// Size of given matrix is m X n
let m = 6;
let n = 3;
let mat = [[ 'O' , 'O' , 'O' ],
[ 'X' , 'X' , 'O' ],
[ 'X' , 'X' , 'O' ],
[ 'O' , 'O' , 'X' ],
[ 'O' , 'O' , 'X' ],
[ 'X' , 'X' , 'O' ]
];
document.write( "Number of rectangular islands is "
+ countIslands(mat, m, n));
// This code is contributed by suresh07. </script> |
<?php // A PHP program to count the // number of rectangular islands // where every island is separated // by a line // Size of given matrix is M X N // 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 )
{ $M = 6;
$N = 3;
// Initialize result
$count = 0;
// Traverse the input matrix
for ( $i = 0; $i < $M ; $i ++)
{
for ( $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 Code
$mat = array ( array ( 'O' , 'O' , 'O' ),
array ( 'X' , 'X' , 'O' ),
array ( 'X' , 'X' , 'O' ),
array ( 'O' , 'O' , 'X' ),
array ( 'O' , 'O' , 'X' ),
array ( 'X' , 'X' , 'O' ));
echo "Number of rectangular islands is "
, countIslands( $mat );
// This code is contributed by nitin mittal ?> |
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:
#include<iostream> 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;
} |
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));
}
} |
# 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 |
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
}
} |
// 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));
|
Number of rectangular islands is 11
Time complexity of this solution is O(M x N).
Auxiliary Space: O(1)