Total number of unit cells covered by all given Rectangles

Given a matrix A[][] consisting of coordinates of N rectangles such that {A[i][0], A[i][1]} representing bottom left coordinate of rectangle and {A[i][2], A[i][3]} representing top right coordinate of rectangle, the task is to find the total number of cells covered by all rectangles.
Examples: 

Input: N = 2, 
A[][] = {{1, 1, 3, 3}, {2, 1, 4, 2}} 
Output:
Explaination: 

First rectangle covers the following 4 cells: 
{(1, 1), (1, 2), (2, 2), (2, 1)}, {(1, 2), (1, 3), (2, 3), (2, 2)}, {(2, 1), (2, 2), (3, 2), (3, 1)}, {(2, 2), (2, 3), (3, 3), (3, 2)} 
Second rectangle encloses 2 cells: 
{(2, 1), (2, 2), (3, 2), (3, 1)}, {(3, 1), (3, 2), (4, 2), (4, 1)} 
Hence both the rectnagles cover 5 cells (since, 1 cell overlaps)

Input: N = 3, 
A[][] = {{1, 3, 4, 5}, {3, 1, 7, 4}, {5, 3, 8, 6}} 
Output: 24 



 

Approach: 
Follow the steps below to solve the problem: 

  1. Create a boolean matrix arr[MAX][MAX], where arr[i][j] = 1 if(i, j) is enclosed by any of the given rectangles. Otherwise, arr[i][j] = 0.
  2. For every rectangle, iterate from from bottom left to top right and for all (i, j) boxes mark them arr[i][j] = 1.
  3. Finally we will maintain a variable area to store the number of cells enclosed. Increment area if arr[i][j] == 1.
  4. Print the final value of area.

Below is the implementation of the above approach :

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to find the 
// number of cells enclosed 
// by the given rectangles 
  
#include <bits/stdc++.h> 
using namespace std; 
#define MAX 1001 
bool arr[MAX][MAX]; 
  
// Update the coordinates lying 
// within the rectangle 
void updateArray(int x1, int y1, 
                int x2, int y2) 
    for (int i = x1; i < x2; i++) { 
        for (int j = y1; j < y2; j++) { 
            // Update arr[i][j] for 
            // all (i, j) lying within 
            // the rectangle 
            arr[i][j] = true
        
    
  
// Function to return the total 
// area covered by rectangles 
int findAreaCovered() 
    // Stores the number 
    // of cells 
    int area = 0; 
  
    for (int i = 0; i < MAX; i++) { 
        for (int j = 0; j < MAX; j++) { 
            // arr[i]][[j]==1 means that grid 
            // is filled by some rectangle 
            if (arr[i][j] == true) { 
                area++; 
            
        
    
  
    return area; 
  
// Driver Code 
int main() 
    int N = 3; 
  
    // (A[i][0], A[i][1]) denotes the 
    // coordinate of the bottom 
    // left of the rectangle 
    // (A[i][2], A[i][3]) denotes the 
    // coordinate of upper right 
    // of the rectangle 
    vector<vector<int> > A = { 
        { 1, 3, 4, 5 }, 
        { 3, 1, 7, 4 }, 
        { 5, 3, 8, 6 } 
    }; 
  
    // Update the coordinates that 
    // lie within the rectangle 
    for (int i = 0; i < N; i++) { 
        updateArray(A[i][0], A[i][1], 
                    A[i][2], A[i][3]); 
    
  
    int area = findAreaCovered(); 
    cout << area; 
    return 0; 

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to find the number
// of cells enclosed by the given 
// rectangles
class GFG{
      
static final int MAX = 1001;
static boolean [][]arr = new boolean[MAX][MAX];
  
// Update the coordinates lying
// within the rectangle
static void updateArray(int x1, int y1,
                        int x2, int y2)
{
    for(int i = x1; i < x2; i++) 
    {
        for(int j = y1; j < y2; j++) 
        {
              
            // Update arr[i][j] for
            // all (i, j) lying within
            // the rectangle
            arr[i][j] = true;
        }
    }
}
  
// Function to return the total
// area covered by rectangles
static int findAreaCovered()
{
      
    // Stores the number
    // of cells
    int area = 0;
  
    for(int i = 0; i < MAX; i++) 
    {
        for(int j = 0; j < MAX; j++)
        {
              
            // arr[i]][[j]==1 means that grid
            // is filled by some rectangle
            if (arr[i][j] == true
            {
                area++;
            }
        }
    }
    return area;
}
  
// Driver Code
public static void main(String[] args)
{
    int N = 3;
  
    // (A[i][0], A[i][1]) denotes the
    // coordinate of the bottom
    // left of the rectangle
    // (A[i][2], A[i][3]) denotes the
    // coordinate of upper right
    // of the rectangle
    int [][]A = { { 1, 3, 4, 5 },
                  { 3, 1, 7, 4 },
                  { 5, 3, 8, 6 } };
  
    // Update the coordinates that
    // lie within the rectangle
    for(int i = 0; i < N; i++)
    {
        updateArray(A[i][0], A[i][1],
                    A[i][2], A[i][3]);
    }
  
    int area = findAreaCovered();
    System.out.print(area);
}
}
  
// This code is contributed by amal kumar choubey

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to find the number
// of cells enclosed by the given 
// rectangles
using System;
  
class GFG{
      
static readonly int MAX = 1001;
static bool [,]arr = new bool[MAX, MAX];
  
// Update the coordinates lying
// within the rectangle
static void updateArray(int x1, int y1,
                        int x2, int y2)
{
    for(int i = x1; i < x2; i++) 
    {
        for(int j = y1; j < y2; j++) 
        {
              
            // Update arr[i,j] for
            // all (i, j) lying within
            // the rectangle
            arr[i, j] = true;
        }
    }
}
  
// Function to return the total
// area covered by rectangles
static int findAreaCovered()
{
      
    // Stores the number
    // of cells
    int area = 0;
  
    for(int i = 0; i < MAX; i++) 
    {
        for(int j = 0; j < MAX; j++)
        {
              
            // arr[i],[j]==1 means that grid
            // is filled by some rectangle
            if (arr[i, j] == true
            {
                area++;
            }
        }
    }
    return area;
}
  
// Driver Code
public static void Main(String[] args)
{
    int N = 3;
  
    // (A[i,0], A[i,1]) denotes the
    // coordinate of the bottom
    // left of the rectangle
    // (A[i,2], A[i,3]) denotes the
    // coordinate of upper right
    // of the rectangle
    int [,]A = { { 1, 3, 4, 5 },
                 { 3, 1, 7, 4 },
                 { 5, 3, 8, 6 } };
  
    // Update the coordinates that
    // lie within the rectangle
    for(int i = 0; i < N; i++)
    {
        updateArray(A[i, 0], A[i, 1],
                    A[i, 2], A[i, 3]);
    }
  
    int area = findAreaCovered();
    Console.Write(area);
}
}
  
// This code is contributed by Rajput-Ji

chevron_right


Output: 

24

Time Complexity : O (N 3) 
Auxiliary Space : O (N 2)
 

competitive-programming-img




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

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

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.