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 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. 

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<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;
}

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

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

<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

<?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
?>

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<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;
}

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.