Skip to content
Related Articles

Related Articles

Size of all connected non-empty cells of a Matrix
  • Last Updated : 28 Dec, 2020

Given a binary matrix mat[][], the task is to find the size of all possible non-empty connected cells. 

An empty cell is denoted by 0 while a non-empty cell is denoted by 1
Two cells are said to be connected if they are adjacent to each other horizontally or vertically, i.e. mat[i][j] = mat[i][j – 1] or mat[i][j] = mat[i][j + 1] or mat[i][j] = mat[i – 1][j] or mat[i][j] = mat[i + 1][j]

Examples: 

Input: mat[][] = {{1, 1, 0, 0, 0}, {0, 1, 0, 0, 1}, {1, 0, 0, 1, 1}, {0, 0, 0, 0, 0}, {1, 0, 1, 0, 1}} 
Output: 3 3 1 1 1 1 
Explanation: 
{mat[0][0], mat[0][1], mat[1][1]}, {mat[1][4], mat[2][3], mat[2][4]}}, {mat[2][0]}, {mat[4][0]}, {mat[4][2]}, {mat[4[4]} are the only possible connections.

Input:mat[][] = {{1, 1, 0, 0, 0}, {1, 1, 0, 1, 1}, {1, 0, 0, 1, 1}, {0, 0, 0, 0, 0}, {0, 0, 1, 1, 1}} 
Output: 5 4 3 



Approach: 
The idea is to use BFS and Recursion on the matrix. 
Follow the steps below: 

  • Initialize a Queue Data Structure and insert a cell(mat[i][j] = 1).
  • Perform BFS on the inserted cell and traverse its adjacent cells.
  • Check for boundary conditions and check if the current element is 1, then flip it to 0.
  • Mark the cell visited and update the size of the connected non-empty cells.
  • Finally, print all the sizes of the connections obtained.

Below is the implementation of the above approach:

C++14




// C++ Program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find size of all the
// islands from the given matrix
int BFS(vector<vector<int> >& mat,
        int row, int col)
{
    int area = 0;
 
    // Initialize a queue for
    // the BFS traversal
    queue<pair<int, int> > Q;
    Q.push({ row, col });
 
    // Iterate untill the
    // queue is empty
    while (!Q.empty()) {
 
        // Top element of queue
        auto it = Q.front();
 
        // Pop the element
        Q.pop();
 
        int r = it.first, c = it.second;
 
        // Check for boundaries
        if (r < 0 || c < 0 || r > 4 || c > 4)
            continue;
 
        // Check if current element is 0
        if (mat[r] == 0)
            continue;
 
        // Check if current element is 1
        if (mat[r] == 1) {
 
            // Mark the cell visited
            mat[r] = 0;
 
            // Incrementing the size
            area++;
        }
 
        // Traverse all neighbors
        Q.push({ r + 1, c });
        Q.push({ r - 1, c });
        Q.push({ r, c + 1 });
        Q.push({ r, c - 1 });
    }
 
    // Return the answer
    return area;
}
 
// Function to print size of each connections
void sizeOfConnections(vector<vector<int> > mat)
{
 
    // Stores the size of each
    // connected non-empty
    vector<int> result;
 
    for (int row = 0; row < 5; ++row) {
        for (int col = 0; col < 5; ++col) {
 
            // Check if the cell is
            // non-empty
            if (mat[row][col] == 1) {
 
                // Function call
                int area = BFS(mat, row, col);
                result.push_back(area);
            }
        }
    }
 
    // Print the answer
    for (int val : result)
        cout << val << " ";
}
 
// Driver Code
int main()
{
 
    vector<vector<int> > mat
        = { { 1, 1, 0, 0, 0 },
            { 1, 1, 0, 1, 1 },
            { 1, 0, 0, 1, 1 },
            { 1, 0, 0, 0, 0 },
            { 0, 0, 1, 1, 1 } };
 
    sizeOfConnections(mat);
 
    return 0;
}

Java




// Java program to implement
// the above approach
import java.util.*;
import java.lang.*;
 
class GFG{
     
static class pair
{
    int first, second;
    pair(int first, int second)
    {
        this.first = first;
        this.second = second;
    }
}
 
// Function to find size of all the
// islands from the given matrix
static int BFS(int[][] mat,
               int row, int col)
{
    int area = 0;
     
    // Initialize a queue for
    // the BFS traversal
    Queue<pair> Q = new LinkedList<>();
    Q.add(new pair(row, col));
 
    // Iterate untill the
    // queue is empty
    while (!Q.isEmpty())
    {
         
        // Top element of queue
        pair it = Q.peek();
 
        // Pop the element
        Q.poll();
 
        int r = it.first, c = it.second;
 
        // Check for boundaries
        if (r < 0 || c < 0 ||
            r > 4 || c > 4)
            continue;
 
        // Check if current element is 0
        if (mat[r] == 0)
            continue;
 
        // Check if current element is 1
        if (mat[r] == 1)
        {
             
            // Mark the cell visited
            mat[r] = 0;
 
            // Incrementing the size
            area++;
        }
 
        // Traverse all neighbors
        Q.add(new pair(r + 1, c));
        Q.add(new pair(r - 1, c));
        Q.add(new pair(r, c + 1));
        Q.add(new pair(r, c - 1));
    }
 
    // Return the answer
    return area;
}
 
// Function to print size of each connections
static void sizeOfConnections(int[][] mat)
{
     
    // Stores the size of each
    // connected non-empty
    ArrayList<Integer> result = new ArrayList<>();
 
    for(int row = 0; row < 5; ++row)
    {
        for(int col = 0; col < 5; ++col)
        {
             
            // Check if the cell is
            // non-empty
            if (mat[row][col] == 1)
            {
                 
                // Function call
                int area = BFS(mat, row, col);
                result.add(area);
            }
        }
    }
     
    // Print the answer
    for(int val : result)
       System.out.print(val + " ");
}
 
// Driver code
public static void main (String[] args)
{
    int[][] mat = { { 1, 1, 0, 0, 0 },
                    { 1, 1, 0, 1, 1 },
                    { 1, 0, 0, 1, 1 },
                    { 1, 0, 0, 0, 0 },
                    { 0, 0, 1, 1, 1 } };
                     
    sizeOfConnections(mat);
}
}
 
// This code is contributed by offbeat

Python3




# Python3 program to implement
# the above approach
from collections import deque
 
# Function to find size of all the
# islands from the given matrix
def BFS(mat, row, col):
     
    area = 0
 
    # Initialize a queue for
    # the BFS traversal
    Q = deque()
    Q.append([row, col])
 
    # Iterate untill the
    # queue is empty
    while (len(Q) > 0):
         
        # Top element of queue
        it = Q.popleft()
 
        # Pop the element
        # Q.pop();
        r, c = it[0], it[1]
 
        # Check for boundaries
        if (r < 0 or c < 0 or r > 4 or c > 4):
            continue
 
        # Check if current element is 0
        if (mat[r] == 0):
            continue
 
        # Check if current element is 1
        if (mat[r] == 1):
 
            # Mark the cell visited
            mat[r] = 0
 
            # Incrementing the size
            area += 1
             
        # Traverse all neighbors
        Q.append([r + 1, c])
        Q.append([r - 1, c])
        Q.append([r, c + 1])
        Q.append([r, c - 1])
 
    # Return the answer
    return area
 
# Function to prsize of each connections
def sizeOfConnections(mat):
     
    # Stores the size of each
    # connected non-empty
    result = []
 
    for row in range(5):
        for col in range(5):
             
            # Check if the cell is
            # non-empty
            if (mat[row][col] == 1):
                 
                # Function call
                area = BFS(mat, row, col);
                result.append(area)
 
    # Print the answer
    for val in result:
        print(val, end = " ")
 
# Driver Code
if __name__ == '__main__':
 
    mat = [ [ 1, 1, 0, 0, 0 ],
            [ 1, 1, 0, 1, 1 ],
            [ 1, 0, 0, 1, 1 ],
            [ 1, 0, 0, 0, 0 ],
            [ 0, 0, 1, 1, 1 ] ]
 
    sizeOfConnections(mat)
 
# This code is contributed by mohit kumar 29

C#




// C# program to implement
// the above approach
using System;
using System.Collections;
using System.Collections.Generic;
 
class GFG{
 
class pair
{
    public int first, second;
     
    public pair(int first, int second)
    {
        this.first = first;
        this.second = second;
    }
}
 
// Function to find size of all the
// islands from the given matrix
static int BFS(int[, ] mat, int row, int col)
{
    int area = 0;
 
    // Initialize a queue for
    // the BFS traversal
    Queue<pair> Q = new Queue<pair>();
    Q.Enqueue(new pair(row, col));
 
    // Iterate untill the
    // queue is empty
    while (Q.Count != 0)
    {
         
        // Top element of queue
        pair it = Q.Peek();
 
        // Pop the element
        Q.Dequeue();
 
        int r = it.first, c = it.second;
 
        // Check for boundaries
        if (r < 0 || c < 0 || r > 4 || c > 4)
            continue;
 
        // Check if current element is 0
        if (mat[r, c] == 0)
            continue;
 
        // Check if current element is 1
        if (mat[r, c] == 1)
        {
             
            // Mark the cell visited
            mat[r, c] = 0;
             
            // Incrementing the size
            area++;
        }
 
        // Traverse all neighbors
        Q.Enqueue(new pair(r + 1, c));
        Q.Enqueue(new pair(r - 1, c));
        Q.Enqueue(new pair(r, c + 1));
        Q.Enqueue(new pair(r, c - 1));
    }
 
    // Return the answer
    return area;
}
 
// Function to print size of each connections
static void sizeOfConnections(int[,] mat)
{
     
    // Stores the size of each
    // connected non-empty
    ArrayList result = new ArrayList();
 
    for(int row = 0; row < 5; ++row)
    {
        for(int col = 0; col < 5; ++col)
        {
             
            // Check if the cell is
            // non-empty
            if (mat[row, col] == 1)
            {
                 
                // Function call
                int area = BFS(mat, row, col);
                result.Add(area);
            }
        }
    }
 
    // Print the answer
    foreach(int val in result)
        Console.Write(val + " ");
}
 
// Driver code
public static void Main(string[] args)
{
    int[, ] mat = { { 1, 1, 0, 0, 0 },
                    { 1, 1, 0, 1, 1 },
                    { 1, 0, 0, 1, 1 },
                    { 1, 0, 0, 0, 0 },
                    { 0, 0, 1, 1, 1 } };
 
    sizeOfConnections(mat);
}
}
 
// This code is contributed by grand_master
Output: 
6 4 3

 

Time Complexity: O(row * col) 
Auxiliary Space: O(row * col)
 

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up
Recommended Articles
Page :