# Maximum area rectangle by picking four sides from array

• Difficulty Level : Medium
• Last Updated : 05 Aug, 2022

Given an array of n positive integers that represent lengths. Find out the maximum possible area whose four sides are picked from the given array. Note that a rectangle can only be formed if there are two pairs of equal values in the given array.

Examples:

```Input : arr[] = {2, 1, 2, 5, 4, 4}
Output : 8
Explanation : Dimension will be 4 * 2

Input : arr[] = {2, 1, 3, 5, 4, 4}
Output : 0
Explanation : No rectangle possible```

Method 1 (Sorting): The task basically reduces to finding two pairs of equal values in the array. If there are more than two pairs, then pick the two pairs with maximum values. A simple solution is to do the following.

1. Sort the given array.
2. Traverse array from largest to smallest value and return two pairs with maximum values.

Implementation:

## C++

 `// CPP program for finding maximum area possible``// of a rectangle``#include ``using` `namespace` `std;` `// function for finding max area``int` `findArea(``int` `arr[], ``int` `n)``{``    ``// sort array in non-increasing order``    ``sort(arr, arr + n, greater<``int``>());` `    ``// Initialize two sides of rectangle``    ``int` `dimension = { 0, 0 };` `    ``// traverse through array``    ``for` `(``int` `i = 0, j = 0; i < n - 1 && j < 2; i++)` `        ``// if any element occurs twice``        ``// store that as dimension``        ``if` `(arr[i] == arr[i + 1])``            ``dimension[j++] = arr[i++];` `    ``// return the product of dimensions``    ``return` `(dimension * dimension);``}` `// driver function``int` `main()``{``    ``int` `arr[] = { 4, 2, 1, 4, 6, 6, 2, 5 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``cout << findArea(arr, n);``    ``return` `0;``}`

## Java

 `// Java program for finding maximum area``// possible of a rectangle``import` `java.util.Arrays;``import` `java.util.Collections;` `public` `class` `GFG``{    ``    ``// function for finding max area``    ``static` `int` `findArea(Integer arr[], ``int` `n)``    ``{``        ``// sort array in non-increasing order``        ``Arrays.sort(arr, Collections.reverseOrder());``     ` `        ``// Initialize two sides of rectangle``        ``int``[] dimension = { ``0``, ``0` `};``     ` `        ``// traverse through array``        ``for` `(``int` `i = ``0``, j = ``0``; i < n - ``1` `&& j < ``2``;``                                           ``i++)``     ` `            ``// if any element occurs twice``            ``// store that as dimension``            ``if` `(arr[i] == arr[i + ``1``])``                ``dimension[j++] = arr[i++];``     ` `        ``// return the product of dimensions``        ``return` `(dimension[``0``] * dimension[``1``]);``    ``}``     ` `    ``// driver function``    ``public` `static` `void` `main(String args[])``    ``{``        ``Integer arr[] = { ``4``, ``2``, ``1``, ``4``, ``6``, ``6``, ``2``, ``5` `};``        ``int` `n = arr.length;``        ``System.out.println(findArea(arr, n));``    ``}``}``// This code is contributed by Sumit Ghosh`

## Python3

 `# Python3 program for finding``# maximum area possible of``# a rectangle` `# function for finding``# max area``def` `findArea(arr, n):` `    ``# sort array in``    ``# non-increasing order``    ``arr.sort(reverse ``=` `True``)` `    ``# Initialize two``    ``# sides of rectangle``    ``dimension ``=` `[``0``, ``0``]` `    ``# traverse through array``    ``i ``=` `0``    ``j ``=` `0``    ``while``(i < n ``-` `1` `and` `j < ``2``):` `        ``# if any element occurs twice``        ``# store that as dimension``        ``if` `(arr[i] ``=``=` `arr[i ``+` `1``]):``            ``dimension[j] ``=` `arr[i]``            ``j ``+``=` `1``            ``i ``+``=` `1``        ``i ``+``=` `1``        ` `    ``# return the product``    ``# of dimensions``    ``return` `(dimension[``0``] ``*``            ``dimension[``1``])` `# Driver code``arr ``=` `[``4``, ``2``, ``1``, ``4``, ``6``, ``6``, ``2``, ``5``]``n ``=` `len``(arr)``print``(findArea(arr, n))` `# This code is contributed``# by Smitha`

## C#

 `// C# program for finding maximum area``// possible of a rectangle``using` `System;``using` `System.Collections;` `class` `GFG``{``// function for finding max area``static` `int` `findArea(``int` `[]arr, ``int` `n)``{``    ``// sort array in non-increasing order``    ``Array.Sort(arr);``    ``Array.Reverse(arr);` `    ``// Initialize two sides of rectangle``    ``int``[] dimension = { 0, 0 };` `    ``// traverse through array``    ``for` `(``int` `i = 0, j = 0;``             ``i < n - 1 && j < 2; i++)` `        ``// if any element occurs twice``        ``// store that as dimension``        ``if` `(arr[i] == arr[i + 1])``            ``dimension[j++] = arr[i++];` `    ``// return the product of dimensions``    ``return` `(dimension * dimension);``}` `// Driver Code``public` `static` `void` `Main(String []args)``{``    ``int` `[]arr = { 4, 2, 1, 4, 6, 6, 2, 5 };``    ``int` `n = arr.Length;``    ``Console.Write(findArea(arr, n));``}``}` `// This code is contributed``// by PrinciRaj1992`

## PHP

 ``

## Javascript

 ``

Output

`24`

Time Complexity: O(n Log n) as one traversal of array takes O(n) time and sorting the array takes n logn extra time , hence overall time taken by the algorithm is O(n Log n)
Auxiliary Space: O(1) since no extra array is used so it takes constant space

Method 2 (Hashing): The idea is to insert all first occurrences of elements in a hash set. For second occurrences, keep track of the maximum of two values.

Below is the implementation of the above approach:

## C++

 `// CPP program for finding maximum area possible``// of a rectangle``#include ``using` `namespace` `std;` `// function for finding max area``int` `findArea(``int` `arr[], ``int` `n)``{``    ``unordered_set<``int``> s;` `    ``// traverse through array``    ``int` `first = 0, second = 0;``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// If this is first occurrence of arr[i],``        ``// simply insert and continue``        ``if` `(s.find(arr[i]) == s.end()) {``            ``s.insert(arr[i]);``            ``continue``;``        ``}` `        ``// If this is second (or more) occurrence,``        ``// update first and second maximum values.``        ``if` `(arr[i] > first) {``            ``second = first;``            ``first = arr[i];``        ``} ``else` `if` `(arr[i] > second)``            ``second = arr[i];``    ``}` `    ``// return the product of dimensions``    ``return` `(first * second);``}` `// driver function``int` `main()``{``    ``int` `arr[] = { 4, 2, 1, 4, 6, 6, 2, 5 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``cout << findArea(arr, n);``    ``return` `0;``}`

## Java

 `// Java program for finding maximum``// area possible of a rectangle``import` `java.util.HashSet;``import` `java.util.Set;` `public` `class` `GFG``{    ``    ``// function for finding max area``    ``static` `int` `findArea(``int` `arr[], ``int` `n)``    ``{``        ``//unordered_set s;``        ` `        ``Set s = ``new` `HashSet<>();``     ` `        ``// traverse through array``        ``int` `first = ``0``, second = ``0``;``        ``for` `(``int` `i = ``0``; i < n; i++) {``     ` `            ``// If this is first occurrence of``            ``// arr[i], simply insert and continue``            ``if` `(!s.contains(arr[i])) {``                ``s.add(arr[i]);``                ``continue``;``            ``}``     ` `            ``// If this is second (or more)``            ``// occurrence, update first and``            ``// second maximum values.``            ``if` `(arr[i] > first) {``                ``second = first;``                ``first = arr[i];``            ``} ``else` `if` `(arr[i] > second)``                ``second = arr[i];``        ``}``     ` `        ``// return the product of dimensions``        ``return` `(first * second);``    ``}``     ` `    ``// driver function``    ``public` `static` `void` `main(String args[])``    ``{``        ``int` `arr[] = { ``4``, ``2``, ``1``, ``4``, ``6``, ``6``, ``2``, ``5` `};``        ``int` `n = arr.length;``        ``System.out.println(findArea(arr, n));``    ``}``}``// This code is contributed by Sumit Ghosh`

## Python3

 `# Python 3 program for finding maximum``# area possible of a rectangle` `# function for finding max area``def` `findArea(arr, n):` `    ``s ``=` `[]` `    ``# traverse through array``    ``first ``=` `0``    ``second ``=` `0``    ``for` `i ``in` `range``(n) :` `        ``# If this is first occurrence of``        ``# arr[i], simply insert and continue``        ``if` `arr[i] ``not` `in` `s:``            ``s.append(arr[i])``            ``continue` `        ``# If this is second (or more) occurrence,``        ``# update first and second maximum values.``        ``if` `(arr[i] > first) :``            ``second ``=` `first``            ``first ``=` `arr[i]``        ``else` `if` `(arr[i] > second):``            ``second ``=` `arr[i]` `    ``# return the product of dimensions``    ``return` `(first ``*` `second)` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``    ` `    ``arr ``=` `[ ``4``, ``2``, ``1``, ``4``, ``6``, ``6``, ``2``, ``5` `]``    ``n ``=` `len``(arr)``    ``print``(findArea(arr, n))` `# This code is contributed by ita_c`

## C#

 `using` `System;``using` `System.Collections.Generic;` `// c# program for finding maximum ``// area possible of a rectangle` `public` `class` `GFG``{``    ``// function for finding max area``    ``public` `static` `int` `findArea(``int``[] arr, ``int` `n)``    ``{``        ``//unordered_set s;` `        ``ISet<``int``> s = ``new` `HashSet<``int``>();` `        ``// traverse through array``        ``int` `first = 0, second = 0;``        ``for` `(``int` `i = 0; i < n; i++)``        ``{` `            ``// If this is first occurrence of ``            ``// arr[i], simply insert and continue``            ``if` `(!s.Contains(arr[i]))``            ``{``                ``s.Add(arr[i]);``                ``continue``;``            ``}` `            ``// If this is second (or more) ``            ``// occurrence, update first and ``            ``// second maximum values.``            ``if` `(arr[i] > first)``            ``{``                ``second = first;``                ``first = arr[i];``            ``}``            ``else` `if` `(arr[i] > second)``            ``{``                ``second = arr[i];``            ``}``        ``}` `        ``// return the product of dimensions``        ``return` `(first * second);``    ``}` `    ``// driver function``    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``int``[] arr = ``new` `int``[] {4, 2, 1, 4, 6, 6, 2, 5};``        ``int` `n = arr.Length;``        ``Console.WriteLine(findArea(arr, n));``    ``}``}` `// This code is contributed by Shrikant13`

## Javascript

 ``

Output

`24`

Time Complexity: O(n) as only one traversal of array is required to complete all operations hence overall complexity turns out be O(n)
Auxiliary Space: O(n) since an unordered set is used, in worst case all elements will be inserted into the set thus occupying O(n) space.