Given an , task is to compute the sum of all possible maximum area rectangle which can be formed from the elements. Also, you can reduce the elements of the by at most 1.

Examples :

Input :a = {, , , , 11, 
            , 11, }
Output : 2
Explanation : 
We can form two  one  (10 * 10) 
and one (11 * 10). Hence, total area = 100 + 110 = 210.

Input : a = { 3, 4, , 6 }
Output : 1
Explanation : 
We can reduce 4 to 3 and 6 to  so that we got 
rectangle of (3 * ). Hence area = 1.

Input : a = { 3, 2, , 2 }
Output : 0

Naive Approach : Check for all possible four elements of the array and then whichever can form a rectangle. In these rectangles, separate all those rectangles which are of maximum area formed by these elements. After getting the rectangles and their , sum them all to get our desired solution.

Efficient Approach : To get the maximum area rectangle, first sort the elements of the array in non-increasing array. After sorting, start the procedure to select the elements of the array. Here, selection of two elements of array (as length of rectangle) is possible if elements of array are equal (a[i] == a[i+1]) or if length of smaller element a[i+1] is one less than a[i] (in this case we have our length a[i+1] because a[i] is decreased by 1). One flag variable is maintained to check that whether we get length and breadth both. After getting length, set the flag variable, now calculate the breadth in the same way as we have done for length and sum the area of rectangle. After getting length and breadth both, again set the flag variable false so that we will now search for a new rectangle. This process is repeated and lastly, final sum of area is returned.

Below is C++ implementation of the above approach.

// CPP code to find sum of all
// area rectangle possible
#include <bits/stdc++.h>
using namespace std;

// Function to find area of rectangles
int MaxTotalRectangleArea(int a[], int n)
{
    // sorting the array in
    // descending order
    sort(a, a + n, greater<int>());

    // store the final sum of
    // all the rectangles area
    // possible
    int sum = 0;
    bool flag = false;

    // temporary variable to store
    // the length of rectangle
    int len;
    
    for (int i = 0; i < n; i++) {
        
        // Selecting the length of rectangle
        // so that difference between any
        // two number is 1 only. Here length
        // is selected so flag is set
        if ((a[i] == a[i + 1] || a[i] - 
             a[i + 1] == 1) && (!flag)) 
        {
            // flag is set means
            // we have got length of
            // rectangle
            flag = true;

            // length is set to
            // a[i+1] so that if 
            // a[i+1] is less than a[i]
            // by 1 then also we have
            // the correct chice for length
            len = a[i + 1];

            // incrementing the counter one
            // time more as we have considered
            // a[i+1] element also so.
            i++;
        }

        // Selecting the width of rectangle
        // so that difference between any
        // two number is 1 only. Here width
        // is selected so now flag is again 
        // unset for next rectangle
        else if ((a[i] == a[i + 1] || 
                  a[i] - a[i + 1] == 1) && (flag)) 
            {
                // area is calculated for
                // rectangle
                sum = sum + a[i + 1] * len;

                // flag is set false
                // for another rectangle
                // which we can get from
                // elements in array
                flag = false;

                // incrementing the counter one
                // time more as we have considered
                // a[i+1] element also so.
                i++;
            }
    }

    return sum;
}

// Driver code
int main()
{
    int a[] = { 10, 10, 10, 10, 11, 10, 
                11, 10, 9, 9, 8, 8 };
    int n = sizeof(a) / sizeof(a[0]);
    
    cout << MaxTotalRectangleArea(a, n);
    
    return 0;
}

Time Complexity: O(nlog(n))
Auxiliary Space: O(1)



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 write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.







Source link
thanks you RSS link
( https://www.geeksforgeeks.org/sum-area-rectangles-possible-array/)

LEAVE A REPLY

Please enter your comment!
Please enter your name here