Maximize Perimeter of Quadrilateral formed by choosing sides from given Array
Given an array arr of size N where each element represents the length of a side, the task is to find the maximum perimeter quadrilateral that can be created using the sides in the given array. If no quadrilateral can be formed print -1.
Examples:
Input: arr[ ] = {3, 1, 2, 4, 2, 1}
Output: 11
Explanation: A quadrilateral of perimeter 4 + 3 + 2 + 2 = 11 can be formed which is the maximum possible.
Input: arr[ ] = {1, 1, 2, 2, 20}
Output: 6
Input: arr[ ] = {1, 2, 4, 10}
Output: -1
Approach: The given problem can be solved by iterating through all the possible combinations of the sides (a, b, c, d) from the given array. It can be observed that sides a, b, c, and d form a valid quadrilateral only if the sum of three smaller sides is greater than or equal to the largest side, or the perimeter of the quadrilateral is greater than or equal to (2 * largest side). Therefore, iterate through all the possible values of (a, b, c, d) from the given array arr[] and check if it forms a valid quadrilateral.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int largestPerimeterQuad( int * arr, int n)
{
int ans = -1;
for ( int i = 0; i < n; i++) {
for ( int j = i + 1; j < n; j++) {
for ( int k = j + 1; k < n; k++) {
for ( int l = k + 1; l < n; l++) {
if (arr[i] + arr[j]
+ arr[k] + arr[l]
>= 2
* max(arr[i],
max(arr[j],
max(arr[k],
arr[l]))))
ans = max(ans, arr[i] + arr[j]
+ arr[k]
+ arr[l]);
}
}
}
}
return ans;
}
int main()
{
int arr[] = { 3, 1, 2, 4, 2, 1 };
int n = sizeof (arr) / sizeof ( int );
cout << largestPerimeterQuad(arr, n);
return 0;
}
|
Java
import java.util.*;
public class GFG
{
static int largestPerimeterQuad( int []arr, int n)
{
int ans = - 1 ;
for ( int i = 0 ; i < n; i++) {
for ( int j = i + 1 ; j < n; j++) {
for ( int k = j + 1 ; k < n; k++) {
for ( int l = k + 1 ; l < n; l++) {
if (arr[i] + arr[j]
+ arr[k] + arr[l]
>= 2
* Math.max(arr[i],
Math.max(arr[j],
Math.max(arr[k],
arr[l]))))
ans = Math.max(ans, arr[i] + arr[j]
+ arr[k]
+ arr[l]);
}
}
}
}
return ans;
}
public static void main(String args[])
{
int []arr = { 3 , 1 , 2 , 4 , 2 , 1 };
int n = arr.length;
System.out.print(largestPerimeterQuad(arr, n));
}
}
|
Python3
def largestPerimeterQuad(arr, n):
ans = - 1
for i in range (n):
for j in range (i + 1 , n):
for k in range (j + 1 , n):
for l in range (k + 1 , n):
if (arr[i] + arr[j]
+ arr[k] + arr[l]
> = 2 * max (arr[i],
max (arr[j],
max (arr[k],
arr[l])))):
ans = max (ans, arr[i] + arr[j] + arr[k] + arr[l])
return ans
arr = [ 3 , 1 , 2 , 4 , 2 , 1 ]
n = len (arr)
print (largestPerimeterQuad(arr, n))
|
C#
using System;
class GFG
{
static int largestPerimeterQuad( int []arr, int n)
{
int ans = -1;
for ( int i = 0; i < n; i++) {
for ( int j = i + 1; j < n; j++) {
for ( int k = j + 1; k < n; k++) {
for ( int l = k + 1; l < n; l++) {
if (arr[i] + arr[j]
+ arr[k] + arr[l]
>= 2
* Math.Max(arr[i],
Math.Max(arr[j],
Math.Max(arr[k],
arr[l]))))
ans = Math.Max(ans, arr[i] + arr[j]
+ arr[k]
+ arr[l]);
}
}
}
}
return ans;
}
public static void Main()
{
int []arr = { 3, 1, 2, 4, 2, 1 };
int n = arr.Length;
Console.Write(largestPerimeterQuad(arr, n));
}
}
|
Javascript
<script>
const largestPerimeterQuad = (arr, n) => {
let ans = -1;
for (let i = 0; i < n; i++) {
for (let j = i + 1; j < n; j++) {
for (let k = j + 1; k < n; k++) {
for (let l = k + 1; l < n; l++) {
if (arr[i] + arr[j]
+ arr[k] + arr[l]
>= 2 * Math.max(arr[i],
Math.max(arr[j],
Math.max(arr[k],
arr[l]))))
ans = Math.max(ans, arr[i] + arr[j]
+ arr[k]
+ arr[l]);
}
}
}
}
return ans;
}
let arr = [3, 1, 2, 4, 2, 1];
let n = arr.length;
document.write(largestPerimeterQuad(arr, n));
</script>
|
Time Complexity: O(N4)
Auxiliary Space: O(1)
Last Updated :
03 Dec, 2021
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...