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

• Difficulty Level : Medium
• Last Updated : 30 Jun, 2021

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:

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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