Given a rectangle [(x1, y1), (x2, y2)] denoting the coordinates of bottom-left corner and top-right corner whose sides are parallel to coordinates axes and N points on its perimeter (at least one on each side). The task is to maximize the area of a triangle formed by these points.
Examples:
Input: rectangle[][]= {{0, 0}, {6, 6}},
coordinates[][] = {{0, 2}, {0, 3}, {0, 5}, {2, 0}, {3, 0}, {6, 0}, {6, 4}, {1, 6}, {6, 6}}
Output: 18
Explanation: Refer to the image below for explanation.
Approach: For finding the maximum area triangle by coordinates on a given rectangle, find the coordinates on each side which are most distant apart. So, suppose there are four sides a, b, c, d where a and c being the length of the rectangle and b, d being the breadth. Now the maximum area will be
MAX ( length * ( distance between farthest coordinates on either of breadth) / 2, breadth * ( distance between farthest coordinates on either of length) / 2 ).
Follow the steps below to solve the given problem.
- Calculate the length = abs(x2 – x1) and breadth = abs(y2 – y1)
- Find the coordinates which are farthest from each other on each side.
- Use the above-mentioned formula to calculate the area.
- Return the area found.
Below is the implementation of the above approach.
// C++ program for above approach #include <bits/stdc++.h> #include <iostream> using namespace std;
// To find the maximum area of triangle void maxTriangleArea( int rectangle[2][2],
int coordinates[][2],
int numberOfCoordinates)
{ int l1min = INT_MAX, l2min = INT_MAX,
l1max = INT_MIN, l2max = INT_MIN,
b1min = INT_MAX, b1max = INT_MIN,
b2min = INT_MAX, b2max = INT_MIN;
int l1Ycoordinate = rectangle[0][1];
int l2Ycoordinate = rectangle[1][1];
int b1Xcoordinate = rectangle[0][0];
int b2Xcoordinate = rectangle[1][0];
// Always consider side parallel
// to x-axis as length and
// side parallel to y-axis as breadth
for ( int i = 0; i < numberOfCoordinates;
i++) {
coordinates[i][1];
// coordinate on l1
if (coordinates[i][1] == l1Ycoordinate) {
l1min = min(l1min,
coordinates[i][0]);
l1max = max(l1max,
coordinates[i][0]);
}
// Coordinate on l2
if (coordinates[i][1] == l2Ycoordinate) {
l2min = min(l2min,
coordinates[i][0]);
l2max = max(l2max,
coordinates[i][0]);
}
// Coordinate on b1
if (coordinates[i][0] == b1Xcoordinate) {
b1min = min(b1min,
coordinates[i][1]);
b1max = max(b1max,
coordinates[i][1]);
}
// Coordinate on b2
if (coordinates[i][0] == b2Xcoordinate) {
b2min = min(b2min,
coordinates[i][1]);
b2max = max(b2max,
coordinates[i][1]);
}
}
// Find maximum possible distance
// on length
int maxOfLength = max( abs (l1max - l1min),
abs (l2max - l2min));
// Find maximum possible distance
// on breadth
int maxofBreadth = max( abs (b1max - b1min),
abs (b2max - b2min));
// Calculate result base * height / 2
float result
= max((maxofBreadth
* ( abs (rectangle[0][0]
- rectangle[1][0]))),
(maxOfLength
* ( abs (rectangle[0][1]
- rectangle[1][1]))))
/ 2.0;
// Print the result
cout << result;
} // Driver Code int main()
{ // Rectangle with x1, y1 and x2, y2
int rectangle[2][2] = { { 0, 0 },
{ 6, 6 } };
// Coordinates on sides of given rectangle
int coordinates[9][2]
= { { 0, 2 }, { 0, 3 }, { 0, 5 },
{ 2, 0 }, { 3, 0 }, { 6, 0 },
{ 6, 4 }, { 1, 6 }, { 6, 6 } };
int numberOfCoordinates
= sizeof (coordinates) / sizeof (coordinates[0]);
maxTriangleArea(rectangle, coordinates,
numberOfCoordinates);
return 0;
} |
// Java program for the above approach import java.io.*;
import java.lang.*;
import java.util.*;
class GFG {
// To find the maximum area of triangle
static void maxTriangleArea( int [ ][ ] rectangle,
int [ ][ ] coordinates,
int numberOfCoordinates)
{
int l1min = Integer.MAX_VALUE, l2min = Integer.MAX_VALUE,
l1max = Integer.MIN_VALUE, l2max = Integer.MIN_VALUE,
b1min = Integer.MAX_VALUE, b1max = Integer.MIN_VALUE,
b2min = Integer.MAX_VALUE, b2max = Integer.MIN_VALUE;
int l1Ycoordinate = rectangle[ 0 ][ 1 ];
int l2Ycoordinate = rectangle[ 1 ][ 1 ];
int b1Xcoordinate = rectangle[ 0 ][ 0 ];
int b2Xcoordinate = rectangle[ 1 ][ 0 ];
// Always consider side parallel
// to x-axis as length and
// side parallel to y-axis as breadth
for ( int i = 0 ; i < numberOfCoordinates; i++) {
// coordinate on l1
if (coordinates[i][ 1 ] == l1Ycoordinate) {
l1min = Math.min(l1min,
coordinates[i][ 0 ]);
l1max = Math.max(l1max,
coordinates[i][ 0 ]);
}
// Coordinate on l2
if (coordinates[i][ 1 ] == l2Ycoordinate) {
l2min = Math.min(l2min,
coordinates[i][ 0 ]);
l2max = Math.max(l2max,
coordinates[i][ 0 ]);
}
// Coordinate on b1
if (coordinates[i][ 0 ] == b1Xcoordinate) {
b1min = Math.min(b1min,
coordinates[i][ 1 ]);
b1max = Math.max(b1max,
coordinates[i][ 1 ]);
}
// Coordinate on b2
if (coordinates[i][ 0 ] == b2Xcoordinate) {
b2min = Math.min(b2min,
coordinates[i][ 1 ]);
b2max = Math.max(b2max,
coordinates[i][ 1 ]);
}
}
// Find maximum possible distance
// on length
int maxOfLength = Math.max(Math.abs(l1max - l1min),
Math.abs(l2max - l2min));
// Find maximum possible distance
// on breadth
int maxofBreadth = Math.max(Math.abs(b1max - b1min),
Math.abs(b2max - b2min));
// Calculate result base * height / 2
int result
= Math.max((maxofBreadth
* (Math.abs(rectangle[ 0 ][ 0 ]
- rectangle[ 1 ][ 0 ]))),
(maxOfLength
* (Math.abs(rectangle[ 0 ][ 1 ]
- rectangle[ 1 ][ 1 ]))))
/ 2 ;
// Print the result
System.out.print(result);
}
// Driver Code
public static void main (String[] args)
{
// Rectangle with x1, y1 and x2, y2
int [ ][ ] rectangle = { { 0 , 0 },
{ 6 , 6 } };
// Coordinates on sides of given rectangle
int [ ][ ] coordinates
= { { 0 , 2 }, { 0 , 3 }, { 0 , 5 },
{ 2 , 0 }, { 3 , 0 }, { 6 , 0 },
{ 6 , 4 }, { 1 , 6 }, { 6 , 6 } };
int numberOfCoordinates
= coordinates.length;
maxTriangleArea(rectangle, coordinates,
numberOfCoordinates);
}
} // This code is contributed by hrithikgarg03188. |
# Python code for the above approach # To find the maximum area of triangle def maxTriangleArea(rectangle, coordinates, numberOfCoordinates):
l1min = 10 * * 9
l2min = 10 * * 9
l1max = 10 * * - 9
l2max = 10 * * - 9
b1min = 10 * * 9
b1max = 10 * * - 9
b2min = 10 * * 9
b2max = 10 * * - 9
l1Ycoordinate = rectangle[ 0 ][ 1 ];
l2Ycoordinate = rectangle[ 1 ][ 1 ];
b1Xcoordinate = rectangle[ 0 ][ 0 ];
b2Xcoordinate = rectangle[ 1 ][ 0 ];
# Always consider side parallel
# to x-axis as length and
# side parallel to y-axis as breadth
for i in range (numberOfCoordinates):
coordinates[i][ 1 ];
# coordinate on l1
if (coordinates[i][ 1 ] = = l1Ycoordinate) :
l1min = min (l1min, coordinates[i][ 0 ]);
l1max = max (l1max, coordinates[i][ 0 ]);
# Coordinate on l2
if (coordinates[i][ 1 ] = = l2Ycoordinate):
l2min = min (l2min, coordinates[i][ 0 ]);
l2max = max (l2max, coordinates[i][ 0 ]);
# Coordinate on b1
if (coordinates[i][ 0 ] = = b1Xcoordinate):
b1min = min (b1min, coordinates[i][ 1 ]);
b1max = max (b1max, coordinates[i][ 1 ]);
# Coordinate on b2
if (coordinates[i][ 0 ] = = b2Xcoordinate):
b2min = min (b2min, coordinates[i][ 1 ]);
b2max = max (b2max, coordinates[i][ 1 ]);
# Find maximum possible distance
# on length
maxOfLength = max ( abs (l1max - l1min), abs (l2max - l2min));
# Find maximum possible distance
# on breadth
maxofBreadth = max ( abs (b1max - b1min), abs (b2max - b2min));
# Calculate result base * height / 2
result = max ((maxofBreadth * ( abs (rectangle[ 0 ][ 0 ] - rectangle[ 1 ][ 0 ]))),
(maxOfLength * ( abs (rectangle[ 0 ][ 1 ] - rectangle[ 1 ][ 1 ])))) / 2.0 ;
# Print the result
print ( int (result));
# Driver Code # Rectangle with x1, y1 and x2, y2 rectangle = [[ 0 , 0 ],[ 6 , 6 ]];
# Coordinates on sides of given rectangle coordinates = [[ 0 , 2 ], [ 0 , 3 ], [ 0 , 5 ],
[ 2 , 0 ], [ 3 , 0 ], [ 6 , 0 ],
[ 6 , 4 ], [ 1 , 6 ], [ 6 , 6 ]];
numberOfCoordinates = len (coordinates)
maxTriangleArea(rectangle, coordinates, numberOfCoordinates); # This code is contributed by gfgking |
// C# program for the above approach using System;
class GFG {
// To find the maximum area of triangle
static void maxTriangleArea( int [,] rectangle,
int [,] coordinates,
int numberOfCoordinates)
{
int l1min = Int32.MaxValue, l2min = Int32.MaxValue,
l1max = Int32.MinValue, l2max = Int32.MinValue,
b1min = Int32.MaxValue, b1max = Int32.MinValue,
b2min = Int32.MaxValue, b2max = Int32.MinValue;
int l1Ycoordinate = rectangle[0,1];
int l2Ycoordinate = rectangle[1,1];
int b1Xcoordinate = rectangle[0,0];
int b2Xcoordinate = rectangle[1,0];
// Always consider side parallel
// to x-axis as length and
// side parallel to y-axis as breadth
for ( int i = 0; i < numberOfCoordinates; i++) {
// coordinate on l1
if (coordinates[i,1] == l1Ycoordinate) {
l1min = Math.Min(l1min,
coordinates[i,0]);
l1max = Math.Max(l1max,
coordinates[i,0]);
}
// Coordinate on l2
if (coordinates[i,1] == l2Ycoordinate) {
l2min = Math.Min(l2min,
coordinates[i,0]);
l2max = Math.Max(l2max,
coordinates[i,0]);
}
// Coordinate on b1
if (coordinates[i,0] == b1Xcoordinate) {
b1min = Math.Min(b1min,
coordinates[i,1]);
b1max = Math.Max(b1max,
coordinates[i,1]);
}
// Coordinate on b2
if (coordinates[i,0] == b2Xcoordinate) {
b2min = Math.Min(b2min,
coordinates[i,1]);
b2max = Math.Max(b2max,
coordinates[i,1]);
}
}
// Find maximum possible distance
// on length
int maxOfLength = Math.Max(Math.Abs(l1max - l1min),
Math.Abs(l2max - l2min));
// Find maximum possible distance
// on breadth
int maxofBreadth = Math.Max(Math.Abs(b1max - b1min),
Math.Abs(b2max - b2min));
// Calculate result base * height / 2
int result
= Math.Max((maxofBreadth
* (Math.Abs(rectangle[0,0]
- rectangle[1,0]))),
(maxOfLength
* (Math.Abs(rectangle[0,1]
- rectangle[1,1]))))
/ 2;
// Print the result
Console.Write(result);
}
// Driver Code
public static void Main ()
{
// Rectangle with x1, y1 and x2, y2
int [,] rectangle = { { 0, 0 },
{ 6, 6 } };
// Coordinates on sides of given rectangle
int [,] coordinates
= { { 0, 2 }, { 0, 3 }, { 0, 5 },
{ 2, 0 }, { 3, 0 }, { 6, 0 },
{ 6, 4 }, { 1, 6 }, { 6, 6 } };
int numberOfCoordinates
= coordinates.GetLength(0);
maxTriangleArea(rectangle, coordinates,
numberOfCoordinates);
}
} // This code is contributed by Samim Hossain Mondal. |
<script> // JavaScript code for the above approach
// To find the maximum area of triangle
function maxTriangleArea(rectangle,
coordinates,
numberOfCoordinates) {
let l1min = Number.MAX_VALUE, l2min = Number.MAX_VALUE,
l1max = Number.MIN_VALUE, l2max = Number.MIN_VALUE,
b1min = Number.MAX_VALUE, b1max = Number.MIN_VALUE,
b2min = Number.MAX_VALUE, b2max = Number.MIN_VALUE;
let l1Ycoordinate = rectangle[0][1];
let l2Ycoordinate = rectangle[1][1];
let b1Xcoordinate = rectangle[0][0];
let b2Xcoordinate = rectangle[1][0];
// Always consider side parallel
// to x-axis as length and
// side parallel to y-axis as breadth
for (let i = 0; i < numberOfCoordinates;
i++) {
coordinates[i][1];
// coordinate on l1
if (coordinates[i][1] == l1Ycoordinate) {
l1min = Math.min(l1min,
coordinates[i][0]);
l1max = Math.max(l1max,
coordinates[i][0]);
}
// Coordinate on l2
if (coordinates[i][1] == l2Ycoordinate) {
l2min = Math.min(l2min,
coordinates[i][0]);
l2max = Math.max(l2max,
coordinates[i][0]);
}
// Coordinate on b1
if (coordinates[i][0] == b1Xcoordinate) {
b1min = Math.min(b1min,
coordinates[i][1]);
b1max = Math.max(b1max,
coordinates[i][1]);
}
// Coordinate on b2
if (coordinates[i][0] == b2Xcoordinate) {
b2min = Math.min(b2min,
coordinates[i][1]);
b2max = Math.max(b2max,
coordinates[i][1]);
}
}
// Find maximum possible distance
// on length
let maxOfLength = Math.max(Math.abs(l1max - l1min),
Math.abs(l2max - l2min));
// Find maximum possible distance
// on breadth
let maxofBreadth = Math.max(Math.abs(b1max - b1min),
Math.abs(b2max - b2min));
// Calculate result base * height / 2
let result
= Math.max((maxofBreadth
* (Math.abs(rectangle[0][0]
- rectangle[1][0]))),
(maxOfLength
* (Math.abs(rectangle[0][1]
- rectangle[1][1]))))
/ 2.0;
// Print the result
document.write(result);
}
// Driver Code
// Rectangle with x1, y1 and x2, y2
let rectangle = [[0, 0],
[6, 6]];
// Coordinates on sides of given rectangle
let coordinates
= [[0, 2], [0, 3], [0, 5],
[2, 0], [3, 0], [6, 0],
[6, 4], [1, 6], [6, 6]];
let numberOfCoordinates
= coordinates.length;
maxTriangleArea(rectangle, coordinates,
numberOfCoordinates);
// This code is contributed by Potta Lokesh
</script>
|
18
Time complexity: O(N), Where N is the number of coordinates given.
Auxiliary Space: O(1)