Related Articles
Total number of unit cells covered by all given Rectangles
• Difficulty Level : Medium
• Last Updated : 05 May, 2021

Given a matrix A[][] consisting of coordinates of N rectangles such that {A[i], A[i]} representing bottom left coordinate of rectangle and {A[i], A[i]} 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:
Explanation: 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 rectangles 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 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++

 `// C++ program to find the``// number of cells enclosed``// by the given rectangles` `#include ``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], A[i]) denotes the``    ``// coordinate of the bottom``    ``// left of the rectangle``    ``// (A[i], A[i]) denotes the``    ``// coordinate of upper right``    ``// of the rectangle``    ``vector > 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], A[i],``                    ``A[i], A[i]);``    ``}` `    ``int` `area = findAreaCovered();``    ``cout << area;``    ``return` `0;``}`

## Java

 `// 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], A[i]) denotes the``    ``// coordinate of the bottom``    ``// left of the rectangle``    ``// (A[i], A[i]) 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`

## Python3

 `# Python3 program to find the``# number of cells enclosed``# by the given rectangles``MAX` `=` `1001``arr ``=` `[[``False` `for` `i ``in` `range``(``MAX``)]``              ``for` `j ``in` `range``(``MAX``)]``            ` `# Update the coordinates lying``# within the rectangle``def` `updateArray(x1, y1, x2, y2):``    ` `    ``for` `i ``in` `range``(x1, x2):``        ``for` `j ``in` `range``(y1, y2):``            ` `            ``# 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``def` `findAreaCovered():` `    ``# Stores the number``    ``# of cells``    ``area ``=` `0``    ` `    ``for` `i ``in` `range``(``MAX``):``        ``for` `j ``in` `range``(``MAX``):``            ` `            ``# arr[i]][[j]==1 means that grid``            ``# is filled by some rectangle``            ``if` `arr[i][j]:``                ``area ``+``=` `1`` ` `    ``return` `area``    ` `# Driver code``if` `__name__``=``=``"__main__"``:``    ` `    ``N ``=` `3`` ` `    ``# (A[i], A[i]) denotes the``    ``# coordinate of the bottom``    ``# left of the rectangle``    ``# (A[i], A[i]) denotes the``    ``# coordinate of upper right``    ``# of the rectangle``    ``A ``=` `[ [ ``1``, ``3``, ``4``, ``5` `],``          ``[ ``3``, ``1``, ``7``, ``4` `],``          ``[ ``5``, ``3``, ``8``, ``6` `] ];``        ` `    ``# Update the coordinates that``    ``# lie within the rectangle``    ``for` `i ``in` `range``(N):``        ``updateArray(A[i][``0``], A[i][``1``],``                    ``A[i][``2``], A[i][``3``]);` `    ``area ``=` `findAreaCovered();``    ``print``(area)` `# This code is contributed by rutvik_56`

## C#

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

## Javascript

 ``
Output:
`24`

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live and Geeks Classes Live USA

My Personal Notes arrow_drop_up