Sum of Areas of Rectangles possible for an array

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

Examples:

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

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

Input: a = { 3, 2, 5, 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 the maximum area formed by these elements. After getting the rectangles and their areas, sum them all to get our desired solution.

Efficient Approach: To get the maximum area rectangle, first sort the elements of the array in the 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 the length, set the flag variable, now calculate the breadth in the same way as we have done for length, and sum the area of the 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, the final sum of the area is returned. 

C++

// 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] a[i+1] is less
            // than by 1 then also
            // we have the correct
            // choice 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;
}

Java

// Java code to find sum of
// all area rectangle possible
import java.io.*;
import java.util.Arrays;
import java.util.*;

class GFG
{
    // Function to find
    // area of rectangles
    static int MaxTotalRectangleArea(Integer []a,
                                     int n)
    {

        // sorting the array in
        // descending order
        Arrays.sort(a, Collections.reverseOrder());

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

        // temporary variable to
        // store the length of rectangle
        int len = 0;

        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] a[i+1] is less
                // than by 1 then also
                // we have the correct
                // choice 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
    public static void main (String args[])
    {
    Integer []a = { 10, 10, 10, 10,
                11, 10, 11, 10,
                9, 9, 8, 8 };
    int n = a.length;

    System.out.print(MaxTotalRectangleArea(a, n));
    }
}
// This code is contributed by
// Manish Shaw(manishshaw1)

Python3

# Python3 code to find sum
# of all area rectangle
# possible

# Function to find
# area of rectangles
def MaxTotalRectangleArea(a, n) :

    # sorting the array in
    # descending order
    a.sort(reverse = True)

    # store the final sum of
    # all the rectangles area
    # possible
    sum = 0
    flag = False

    # temporary variable to store
    # the length of rectangle
    len = 0
    i = 0

    while (i < n-1) :
        if(i != 0) :
            i = i + 1

        # 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] or
             a[i] - a[i + 1] == 1)
              and flag == False) :

            # 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 choice for length
            len = a[i + 1]

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

        # 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
        elif ((a[i] == a[i + 1] or
              a[i] - a[i + 1] == 1)
                and flag == True) :

            # 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 = i + 1

    return sum

# Driver code
a = [ 10, 10, 10, 10, 11, 10,
          11, 10, 9, 9, 8, 8 ]
n = len(a)

print (MaxTotalRectangleArea(a, n))

# This code is contributed by
# Manish Shaw (manishshaw1)

C#

// C# code to find sum of all area rectangle
// possible
using System;

class GFG {

    // Function to find
    // area of rectangles
    static int MaxTotalRectangleArea(int []a,
                                       int n)
    {

        // sorting the array in descending
        // order
        Array.Sort(a);
        Array.Reverse(a);

        // 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 =0;

        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] a[i+1] is less
                // than by 1 then also
                // we have the correct
                // choice 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
    static public void Main ()
    {
            int []a = { 10, 10, 10, 10,
                        11, 10, 11, 10,
                        9, 9, 8, 8 };
    int n = a.Length;

    Console.WriteLine(
                MaxTotalRectangleArea(a, n));
    }
}

// This code is contributed by anuj_67.

PHP

<?php
// PHP code to find sum
// of all area rectangle
// possible

// Function to find
// area of rectangles
function MaxTotalRectangleArea( $a, $n)
{
    // sorting the array in
    // descending order
    rsort($a);

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

    // temporary variable to store
    // the length of rectangle
    $len;

    for ( $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] or $a[$i] -
             $a[$i + 1] == 1) and (!$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 choice 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] or
                  $a[$i] - $a[$i + 1] == 1) and
                 ($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
$a = array( 10, 10, 10, 10,
            11, 10, 11, 10,
            9, 9, 8, 8 );
$n = count($a);

echo MaxTotalRectangleArea($a, $n);

//This code is contributed by anuj_67.
?>

Javascript

<script>

// Javascript code to find sum of all
// area rectangle possible

// Function to find
// area of rectangles
function MaxTotalRectangleArea( a, n)
{
    // sorting the array in
    // descending order
    a.sort();
    a.reverse();

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

    // temporary variable to store
    // the length of rectangle
    let len;

    for (let 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] a[i+1] is less
            // than by 1 then also
            // we have the correct
            // choice 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

let a = [ 10, 10, 10, 10,
        11, 10, 11, 10,
        9, 9, 8, 8 ];
let n = a.length;

document.write(MaxTotalRectangleArea(a, n));

</script>

Output

282

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