Skip to content
Related Articles

Related Articles

Improve Article

Area of the largest rectangle formed by lines parallel to X and Y axis from given set of points

  • Last Updated : 26 Apr, 2021

Given an array arr[] consisting of N pair of integers representing coordinates of N points, the task is to find the area of the largest rectangle formed by straight lines drawn parallel to X and Y-axis from a given set of points.

Examples:

Input: arr[] = {{0, 0}, {1, 1}}
Output: 1
Explanation: The area of the largest rectangle is 1 formed by the coordinates (0, 0), (0, 1), (1, 0), (1, 1).

Input: arr[] = {{-2, 0}, {2, 0}, {4, 0}, {4, 2}}
Output: 8
Explanation: The area of the largest rectangle possible is 8 ( length = 4 and breadth = 2 ) by the coordinates (-2, 0), (2, 0), (2, 2), (-2, 2).

Approach: The problem can be solved using the sorting technique. Follow the steps below to solve the problem:



  1. Store X and Y coordinates in two different arrays, say x[] and y[].
  2. Sort the arrays x[] and y[].
  3. Find the maximum adjacent difference from both arrays and store in variables X_Max and Y_Max.
  4. The maximum rectangle area possible is the product of X_Max and Y_Max.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the area of the largest
// rectangle formed by lines parallel to X
// and Y axis from given set of points
int maxRectangle(vector<vector<int> > sequence,
                 int size)
{
    // Initialize two arrays
    long long int X_Cord[size], Y_Cord[size];
 
    // Store x and y coordinates
    for (int i = 0; i < size; i++) {
        X_Cord[i] = sequence[i][0];
        Y_Cord[i] = sequence[i][1];
    }
 
    // Sort arrays
    sort(X_Cord, X_Cord + size);
    sort(Y_Cord, Y_Cord + size);
 
    // Initialize max differences
    long long int X_Max = 0, Y_Max = 0;
 
    // Find max adjacent differences
    for (int i = 0; i < size - 1; i++) {
        X_Max = max(X_Max, X_Cord[i + 1]
                               - X_Cord[i]);
        Y_Max = max(Y_Max, Y_Cord[i + 1]
                               - Y_Cord[i]);
    }
 
    // Return answer
    return X_Max * Y_Max;
}
 
// Driver Code
int main()
{
    // Given points
    vector<vector<int> > point
        = { { -2, 0 }, { 2, 0 }, { 4, 0 }, { 4, 2 } };
 
    // Total points
    int n = point.size();
 
    // Function call
    cout << maxRectangle(point, n);
}

Java




// Java program for the above approach
import java.util.*;
 
class GFG{
 
// Function to return the area of the largest
// rectangle formed by lines parallel to X
// and Y axis from given set of points
static int maxRectangle(int[][] sequence,
                        int size)
{
     
    // Initialize two arrays
    int[] X_Cord = new int[size];
    int[] Y_Cord = new int[size];
 
    // Store x and y coordinates
    for(int i = 0; i < size; i++)
    {
        X_Cord[i] = sequence[i][0];
        Y_Cord[i] = sequence[i][1];
    }
 
    // Sort arrays
    Arrays.sort(X_Cord);
    Arrays.sort(Y_Cord);
 
    // Initialize max differences
    int X_Max = 0, Y_Max = 0;
 
    // Find max adjacent differences
    for(int i = 0; i < size - 1; i++)
    {
        X_Max = Math.max(X_Max, X_Cord[i + 1] -
                                X_Cord[i]);
        Y_Max = Math.max(Y_Max, Y_Cord[i + 1] -
                                Y_Cord[i]);
    }
     
    // Return answer
    return X_Max * Y_Max;
}
 
// Driver Code
public static void main(String[] args)
{
     
    // Given points
    int[][] point = { { -2, 0 }, { 2, 0 },
                      { 4, 0 }, { 4, 2 } };
 
    // Total points
    int n = point.length;
 
    // Function call
    System.out.print(maxRectangle(point, n));
}
}
 
// This code is contributed by shikhasingrajput

Python3




# Python3 program for the
# above approach
 
# Function to return the
# area of the largest
# rectangle formed by lines
# parallel to X and Y axis
# from given set of points
def maxRectangle(sequence, size):
 
    # Initialize two arrays
    X_Cord = [0] * size
    Y_Cord = [0] * size
 
    # Store x and y coordinates
    for i in range(size):
        X_Cord[i] = sequence[i][0]
        Y_Cord[i] = sequence[i][1]
 
    # Sort arrays
    X_Cord.sort()
    Y_Cord.sort()
 
    # Initialize max differences
    X_Max = 0
    Y_Max = 0
 
    # Find max adjacent differences
    for i in range(size - 1):
        X_Max = max(X_Max,
                    X_Cord[i + 1] -
                    X_Cord[i])
        Y_Max = max(Y_Max,
                    Y_Cord[i + 1] -
                    Y_Cord[i])
 
    # Return answer
    return X_Max * Y_Max
 
# Driver Code
if __name__ == "__main__":
   
    # Given points
    point = [[-2, 0], [2, 0],
             [4, 0], [4, 2]]
 
    # Total points
    n = len(point)
 
    # Function call
    print(maxRectangle(point, n))
 
# This code is contributed by Chitranayal

C#




// C# program for the above approach
using System;
 
class GFG{
 
// Function to return the area of the largest
// rectangle formed by lines parallel to X
// and Y axis from given set of points
static int maxRectangle(int[,] sequence,
                        int size)
{
     
    // Initialize two arrays
    int[] X_Cord = new int[size];
    int[] Y_Cord = new int[size];
     
    // Store x and y coordinates
    for(int i = 0; i < size; i++)
    {
        X_Cord[i] = sequence[i, 0];
        Y_Cord[i] = sequence[i, 1];
    }
 
    // Sort arrays
    Array.Sort(X_Cord);
    Array.Sort(Y_Cord);
 
    // Initialize max differences
    int X_Max = 0, Y_Max = 0;
 
    // Find max adjacent differences
    for(int i = 0; i < size - 1; i++)
    {
        X_Max = Math.Max(X_Max, X_Cord[i + 1] -
                                X_Cord[i]);
        Y_Max = Math.Max(Y_Max, Y_Cord[i + 1] -
                                Y_Cord[i]);
    }
     
    // Return answer
    return X_Max * Y_Max;
}
 
// Driver Code
public static void Main(String[] args)
{
     
    // Given points
    int[,] point = { { -2, 0 }, { 2, 0 },
                     { 4, 0 }, { 4, 2 } };
 
    // Total points
    int n = point.GetLength(0);
 
    // Function call
    Console.Write(maxRectangle(point, n));
}
}
 
// This code is contributed by shikhasingrajput

Javascript




<script>
 
// JavaScript program to implement
// the above approach
 
// Function to return the area of the largest
// rectangle formed by lines parallel to X
// and Y axis from given set of polets
function maxRectangle(sequence, size)
{
      
    // Initialize two arrays
    let X_Cord = [];
    let Y_Cord = [];
  
    // Store x and y coordinates
    for(let i = 0; i < size; i++)
    {
        X_Cord[i] = sequence[i][0];
        Y_Cord[i] = sequence[i][1];
    }
  
    // Sort arrays
    X_Cord.sort();
    Y_Cord.sort();
  
    // Initialize max differences
    let X_Max = 0, Y_Max = 0;
  
    // Find max adjacent differences
    for(let i = 0; i < size - 1; i++)
    {
        X_Max = Math.max(X_Max, X_Cord[i + 1] -
                                X_Cord[i]);
        Y_Max = Math.max(Y_Max, Y_Cord[i + 1] -
                                Y_Cord[i]);
    }
      
    // Return answer
    return X_Max * Y_Max;
}
 
// Driver Code
 
    // Given points
    let point = [[ -2, 0 ], [ 2, 0 ],
                 [ 4, 0 ], [ 4, 2 ]];
  
    // Total points
    let n = point.length;
  
    // Function call
    document.write(maxRectangle(point, n));
           
</script>
Output: 
8

 

Time Complexity: O(N*log(N)) where N is the total number of points.
Auxiliary Space: O(N) 

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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :