 GFG App
Open App Browser
Continue

# Number of rectangles with given area in an N*M grid

Given three positive integers N, M, and A, the task is to count the number of rectangles with area equal to A present in an M * N grid.

Examples:

Input: N = 2, M = 2, A = 2
Output:
Explanation:
In the given grid of size 2 × 2, 2 rectangles of dimension 2 × 1 and 2 rectangles of dimension 1 × 2 can be inscribed.
Therefore, the required output is 4.

Input: N = 2, M = 2, A = 3
Output: 0
Explanation:
The possible rectangles with area A (= 3) are of dimensions either 1 × 3 or 3 × 1.
But, the maximum length of a side in the grid can only be 2. Therefore, no rectangles can be inscribed within the grid.

Approach: The problem can be solved based on the following observations:

The total number of ways to select a segment of length X on the segment of length M is equal to (M – X + 1)
Therefore, the total count of rectangles of size X * Y in the rectangle of size M * N is equal to (M – X + 1) * (N – Y + 1).

Follow the steps below to solve the problem:

• Iterate over the range [1, √A]. For every ith iteration, find all possible values of length and breadth of the rectangles, say { i, (A / i)} or { (A / i), i } within the given grid.
• Iterate over all possible values of length say X and breadth say, Y and increment the count of rectangles by (M – X + 1) * (N – Y + 1).
• Finally, print the count obtained.

Below is the implementation of the above approach:

## C++

 `// C++ program of the above approach` `#include ` `using` `namespace` `std;`   `// Function to find the count of rectangles` `// in an M * N grid such that the area of` `// the rectangles is equal to A` `int` `count_number(``int` `N, ``int` `M, ``int` `A)` `{`   `    ``// Stores all possible values of length` `    ``// and breadth whose area equal to A` `    ``vector > v;`   `    ``// Calculate all divisors of A` `    ``for` `(``int` `i = 1; i * i <= A; i++) {`   `        ``// If N is divisible by i` `        ``if` `(N % i == 0) {`   `            ``// Stores length of the rectangle` `            ``int` `length = i;`   `            ``// Stores breadth of the rectangle` `            ``int` `breadth = A / i;`   `            ``// If length of rectangle is not` `            ``// equal to breadth of rectangle` `            ``if` `(length != breadth) {`   `                ``// Insert { length, breadth }` `                ``v.push_back({ length, breadth });`   `                ``// Insert { breadth, length }` `                ``v.push_back({ breadth, length });` `            ``}` `            ``else` `{`   `                ``// Insert { length, breadth}` `                ``// because both are equal` `                ``v.push_back({ length, breadth });` `            ``}` `        ``}` `    ``}`   `    ``// Stores the count of rectangles` `    ``// in a grid whose area equal to A` `    ``long` `long` `total = 0;`   `    ``// Iterate over all possible` `    ``// values of { length, breadth }` `    ``for` `(``auto` `it : v) {`   `        ``// Stores total count of ways to` `        ``// select a segment of length it.first` `        ``// on the segment of length M` `        ``int` `num1 = (max(0, M - it.first + 1));`   `        ``// Stores total count of ways to` `        ``// select a segment of length it.second` `        ``// on the segment of length N` `        ``int` `num2 = (max(0, N - it.second + 1));`   `        ``// Update total` `        ``total += (num1 * num2);` `    ``}`   `    ``return` `total;` `}`   `// Drivers Code` `int` `main()` `{`   `    ``// Input` `    ``int` `N = 2, M = 2, A = 2;`   `    ``// Print the result` `    ``cout << count_number(N, M, A) << endl;` `}`

## Java

 `// Java program of the above approach` `import` `java.util.*;` `class` `GFG` `{` `    `  `static` `class` `pair` `{ ` `    ``int` `first, second; ` `    ``public` `pair(``int` `first, ``int` `second)  ` `    ``{ ` `        ``this``.first = first; ` `        ``this``.second = second; ` `    ``}    ` `} ` `  `  `// Function to find the count of rectangles` `// in an M * N grid such that the area of` `// the rectangles is equal to A` `static` `int` `count_number(``int` `N, ``int` `M, ``int` `A)` `{`   `    ``// Stores all possible values of length` `    ``// and breadth whose area equal to A` `    ``Vector v = ``new` `Vector();`   `    ``// Calculate all divisors of A` `    ``for` `(``int` `i = ``1``; i * i <= A; i++) ` `    ``{`   `        ``// If N is divisible by i` `        ``if` `(N % i == ``0``)` `        ``{`   `            ``// Stores length of the rectangle` `            ``int` `length = i;`   `            ``// Stores breadth of the rectangle` `            ``int` `breadth = A / i;`   `            ``// If length of rectangle is not` `            ``// equal to breadth of rectangle` `            ``if` `(length != breadth) ` `            ``{`   `                ``// Insert { length, breadth }` `                ``v.add(``new` `pair(length, breadth));`   `                ``// Insert { breadth, length }` `                ``v.add(``new` `pair(breadth, length));` `            ``}` `            ``else` `            ``{`   `                ``// Insert { length, breadth}` `                ``// because both are equal` `                ``v.add(``new` `pair(length, breadth));` `            ``}` `        ``}` `    ``}`   `    ``// Stores the count of rectangles` `    ``// in a grid whose area equal to A` `    ``int` `total = ``0``;`   `    ``// Iterate over all possible` `    ``// values of { length, breadth }` `    ``for` `(pair it : v)` `    ``{`   `        ``// Stores total count of ways to` `        ``// select a segment of length it.first` `        ``// on the segment of length M` `        ``int` `num1 = (Math.max(``0``, M - it.first + ``1``));`   `        ``// Stores total count of ways to` `        ``// select a segment of length it.second` `        ``// on the segment of length N` `        ``int` `num2 = (Math.max(``0``, N - it.second + ``1``));`   `        ``// Update total` `        ``total += (num1 * num2);` `    ``}` `    ``return` `total;` `}`   `// Drivers Code` `public` `static` `void` `main(String[] args)` `{`   `    ``// Input` `    ``int` `N = ``2``, M = ``2``, A = ``2``;`   `    ``// Print the result` `    ``System.out.print(count_number(N, M, A) +``"\n"``);` `}` `}`   `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program of the above approach`   `# Function to find the count of rectangles` `# in an M * N grid such that the area of` `# the rectangles is equal to A` `def` `count_number(N, M, A):`   `    ``# Stores all possible values of length` `    ``# and breadth whose area equal to A` `    ``v ``=` `[]`   `    ``# Calculate all divisors of A` `    ``for` `i ``in` `range``(``1``, A ``+` `1``):`   `        ``if` `i ``*` `i > A:` `            ``break`   `        ``# If N is divisible by i` `        ``if` `(N ``%` `i ``=``=` `0``):`   `            ``# Stores length of the rectangle` `            ``length ``=` `i`   `            ``# Stores breadth of the rectangle` `            ``breadth ``=` `A ``/``/` `i`   `            ``# If length of rectangle is not` `            ``# equal to breadth of rectangle` `            ``if` `(length !``=` `breadth):`   `                ``# Insert { length, breadth }` `                ``v.append([length, breadth ])`   `                ``# Insert { breadth, length }` `                ``v.append([breadth, length ])` `            ``else``:` `                ``# Insert { length, breadth}` `                ``# because both are equal` `                ``v.append([length, breadth ])`   `    ``# Stores the count of rectangles` `    ``# in a grid whose area equal to A` `    ``total ``=` `0`   `    ``# Iterate over all possible` `    ``# values of { length, breadth }` `    ``for` `it ``in` `v:`   `        ``# Stores total count of ways to` `        ``# select a segment of length it.first` `        ``# on the segment of length M` `        ``num1 ``=` `(``max``(``0``, M ``-` `it[``0``] ``+` `1``))`   `        ``# Stores total count of ways to` `        ``# select a segment of length it.second` `        ``# on the segment of length N` `        ``num2 ``=` `(``max``(``0``, N ``-` `it[``1``] ``+` `1``))`   `        ``# Update total` `        ``total ``+``=` `(num1 ``*` `num2)` `    ``return` `total`   `# Drivers Code` `if` `__name__ ``=``=` `'__main__'``:`   `    ``# Input` `    ``N, M, A ``=` `2``, ``2``, ``2`   `    ``# Print the result` `    ``print``(count_number(N, M, A))`   `# This code is contributed by mohit kumar 29.`

## C#

 `// C# implementation of the approach ` `using` `System; ` `using` `System.Collections.Generic; ` `class` `GFG ` `{`   `  ``public` `class` `pair  ` `  ``{  ` `    ``public` `int` `first, second;  ` `    ``public` `pair(``int` `first, ``int` `second)  ` `    ``{  ` `      ``this``.first = first;  ` `      ``this``.second = second;  ` `    ``}  ` `  ``}`   `  ``// Function to find the count of rectangles` `  ``// in an M * N grid such that the area of` `  ``// the rectangles is equal to A` `  ``static` `int` `count_number(``int` `N, ``int` `M, ``int` `A)` `  ``{`   `    ``// Stores all possible values of length` `    ``// and breadth whose area equal to A` `    ``List v = ``new` `List(); `   `    ``// Calculate all divisors of A` `    ``for` `(``int` `i = 1; i * i <= A; i++) ` `    ``{`   `      ``// If N is divisible by i` `      ``if` `(N % i == 0)` `      ``{`   `        ``// Stores length of the rectangle` `        ``int` `length = i;`   `        ``// Stores breadth of the rectangle` `        ``int` `breadth = A / i;`   `        ``// If length of rectangle is not` `        ``// equal to breadth of rectangle` `        ``if` `(length != breadth) ` `        ``{`   `          ``v.Add(``new` `pair(length, breadth));`   `          ``// Insert { breadth, length }` `          ``v.Add(``new` `pair(breadth, length));` `        ``}` `        ``else` `        ``{`   `          ``// Insert { length, breadth}` `          ``// because both are equal` `          ``v.Add(``new` `pair(length, breadth));` `        ``}` `      ``}` `    ``}`   `    ``// Stores the count of rectangles` `    ``// in a grid whose area equal to A` `    ``int` `total = 0;`   `    ``// Iterate over all possible` `    ``// values of { length, breadth }` `    ``foreach` `(pair it ``in` `v)` `    ``{`   `      ``// Stores total count of ways to` `      ``// select a segment of length it.first` `      ``// on the segment of length M` `      ``int` `num1 = (Math.Max(0, M - it.first + 1));`   `      ``// Stores total count of ways to` `      ``// select a segment of length it.second` `      ``// on the segment of length N` `      ``int` `num2 = (Math.Max(0, N - it.second + 1));`   `      ``// Update total` `      ``total += (num1 * num2);` `    ``}` `    ``return` `total;` `  ``}`   `  ``// Driver code ` `  ``public` `static` `void` `Main(String[] args) ` `  ``{ ` `    ``// Input` `    ``int` `N = 2, M = 2, A = 2;`   `    ``// Print the result` `    ``Console.Write(count_number(N, M, A) +``"\n"``);` `  ``} ` `} `   `// This code is contributed by susmitakundugoaldang`

## Javascript

 ``

Output:

`4`

Time Complexity: O(sqrt(N))
Auxiliary Space: O(sqrt(N))

My Personal Notes arrow_drop_up