# Maximum Perimeter Triangle from array

Given an Array of non-negative integers. Find out three elements from this array which form a triangle of maximum perimeter.

Examples :

```Input : {6, 1, 6, 5, 8, 4}
Output : 20

Input : {2, 20, 7, 55, 1, 33, 12, 4}
Output : Triangle formation is not possible.

Input: {33, 6, 20, 1, 8, 12, 5, 55, 4, 9}
Output: 41
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Naive Solution:
The brute force solution is: check for all combination of 3 elements whether it forms a triangle or not and update the maximum perimeter if it forms a triangle. Complexity of naive solution is O(n3). Below is the code for it.

## C++

 `// Brute force solution to find ` `// out maximum perimeter triangle which ` `// can be formed using the elements ` `// of the given array ` `#include ` `#include ` ` `  `using` `namespace` `std; ` ` `  `// Function to find out maximum perimeter ` `void` `maxPerimeter(``int` `arr[], ``int` `n){ ` ` `  `    ``// initialize maximum perimeter ` `    ``// as 0. ` `    ``int` `maxi = 0; ` ` `  `    ``// pick up 3 different elements ` `    ``// from the array. ` `    ``for` `(``int` `i = 0; i < n - 2; i++){ ` `        ``for` `(``int` `j = i + 1; j < n - 1; j++){ ` `            ``for` `(``int` `k = j + 1; k < n; k++){ ` ` `  `                ``// a, b, c are 3 sides of the triangle ` `                ``int` `a = arr[i]; ` `                ``int` `b = arr[j]; ` `                ``int` `c = arr[k]; ` ` `  `                ``// check whether a, b, c forms ` `                ``// a triangle or not. ` `                ``if` `(a < b+c && b < c+a && c < a+b){ ` ` `  `                    ``// if it forms a triangle ` `                    ``// then update the maximum value. ` `                    ``maxi = max(maxi, a+b+c); ` `                ``} ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// If maximum perimeter is non-zero ` `    ``// then print it. ` `    ``if` `(maxi) cout << ``"Maximum Perimeter is: "`  `                   ``<< maxi << endl; ` ` `  `    ``// otherwise no triangle formation ` `    ``// is possible. ` `    ``else` `cout << ``"Triangle formation "` `        ``<< ``"is not possible."` `<< endl; ` `} ` ` `  `// Driver Program ` `int` `main() ` `{ ` `    ``// test case 1 ` `    ``int` `arr1[6] = {6, 1, 6, 5, 8, 4}; ` `    ``maxPerimeter(arr1, 6); ` ` `  `    ``// test case 2 ` `    ``int` `arr2[8] = {2, 20, 7, 55, 1, ` `                    ``33, 12, 4}; ` `    ``maxPerimeter(arr2, 8); ` ` `  `    ``// test case 3 ` `    ``int` `arr3[10] = {33, 6, 20, 1, 8, ` `                    ``12, 5, 55, 4, 9}; ` `    ``maxPerimeter(arr3, 10); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Brute force solution to find out maximum  ` `// perimeter triangle which can be formed  ` `// using the elements of the given array ` `import` `java.io.*; ` ` `  `class` `GFG { ` ` `  `    ``// Function to find out maximum perimeter ` `    ``static` `void` `maxPerimeter(``int` `arr[], ``int` `n) ` `    ``{ ` `     `  `        ``// initialize maximum perimeter as 0. ` `        ``int` `maxi = ``0``; ` `     `  `        ``// pick up 3 different elements ` `        ``// from the array. ` `        ``for` `(``int` `i = ``0``; i < n - ``2``; i++) ` `        ``{ ` `            ``for` `(``int` `j = i + ``1``; j < n - ``1``; j++) ` `            ``{ ` `                ``for` `(``int` `k = j + ``1``; k < n; k++)  ` `                ``{ ` `     `  `                    ``// a, b, c are 3 sides of ` `                    ``// the triangle ` `                    ``int` `a = arr[i]; ` `                    ``int` `b = arr[j]; ` `                    ``int` `c = arr[k]; ` `     `  `                    ``// check whether a, b, c  ` `                    ``// forms a triangle or not. ` `                    ``if` `(a < b+c && b < c+a && c < a+b) ` `                    ``{ ` `     `  `                        ``// if it forms a triangle ` `                        ``// then update the maximum  ` `                        ``// value. ` `                        ``maxi = Math.max(maxi, a+b+c); ` `                    ``} ` `                ``} ` `            ``} ` `        ``} ` `     `  `        ``// If maximum perimeter is non-zero ` `        ``// then print it. ` `        ``if` `(maxi > ``0``)  ` `        ``System.out.println( ``"Maximum Perimeter is: "` `                                             ``+ maxi); ` `     `  `        ``// otherwise no triangle formation ` `        ``// is possible. ` `        ``else` `        ``System.out.println( ``"Triangle formation "` `                              ``+ ``"is not possible."` `); ` `    ``} ` `     `  `    ``// Driver Program ` `    ``public` `static` `void` `main (String[] args) ` `    ``{ ` `         `  `        ``// test case 1 ` `        ``int` `arr1[] = {``6``, ``1``, ``6``, ``5``, ``8``, ``4``}; ` `        ``maxPerimeter(arr1, ``6``); ` `     `  `        ``// test case 2 ` `        ``int` `arr2[] = {``2``, ``20``, ``7``, ``55``, ``1``, ``33``, ``12``, ``4``}; ` `        ``maxPerimeter(arr2, ``8``); ` `     `  `        ``// test case 3 ` `        ``int` `arr3[] = {``33``, ``6``, ``20``, ``1``, ``8``, ` `                                ``12``, ``5``, ``55``, ``4``, ``9``}; ` `        ``maxPerimeter(arr3, ``10``); ` `    ``} ` `} ` ` `  `// This code is contributed by anuj_67. `

## Python

 `# Brute force solution to find ` `# out maximum perimeter triangle  ` `# which can be formed using the  ` `# elements of the given array ` ` `  `# Function to find out  ` `# maximum perimeter ` `def` `maxPerimeter(arr): ` `    ``maxi ``=` `0` `    ``n ``=` `len``(arr) ` `     `  `    ``# pick up 3 different  ` `    ``# elements from the array. ` `    ``for` `i ``in` `range``(n ``-` `2``): ` `        ``for` `j ``in` `range``(i ``+` `1``, n ``-` `1``): ` `            ``for` `k ``in` `range``(j ``+` `1``, n): ` `                 `  `                ``# a, b, c are 3 sides  ` `                ``# of the triangle ` `                ``a ``=` `arr[i] ` `                ``b ``=` `arr[j] ` `                ``c ``=` `arr[k] ` `                ``if``(a < b ``+` `c ``and` `b < a ``+` `c  ` `                             ``and` `c < a ``+` `b): ` `                    ``maxi ``=` `max``(maxi, a ``+` `b ``+` `c) ` ` `  `    ``if``(maxi ``=``=` `0``): ` `        ``return` `"Triangle formation is not possible"` `    ``else``: ` `        ``return` `"Maximum Perimeter is: "``+` `str``(maxi) ` ` `  `# Driver code ` `def` `main(): ` `    ``arr1 ``=` `[``6``, ``1``, ``6``, ``5``, ``8``, ``4``] ` `    ``a ``=` `maxPerimeter(arr1) ` `    ``print``(a) ` ` `  `    ``arr2 ``=` `[``2``, ``20``, ``7``, ``55``,  ` `            ``1``, ``33``, ``12``, ``4``] ` `    ``a ``=` `maxPerimeter(arr2) ` `    ``print``(a) ` ` `  `    ``arr3 ``=` `[``33``, ``6``, ``20``, ``1``, ``8``,  ` `            ``12``, ``5``, ``55``, ``4``, ``9``] ` `    ``a ``=` `maxPerimeter(arr3) ` `    ``print``(a) ` ` `  `if` `__name__``=``=``'__main__'``: ` `    ``main() ` ` `  `# This code is contributed  ` `# by Pritha Updhayay `

## C#

 `// Brute force solution to find out  ` `// maximum perimeter triangle which  ` `// can be formed using the elements  ` `// of the given array ` `using` `System; ` ` `  `class` `GFG  ` `{ ` ` `  `    ``// Function to find out  ` `    ``// maximum perimeter ` `    ``static` `void` `maxPerimeter(``int` `[]arr,      ` `                             ``int` `n) ` `    ``{ ` `     `  `        ``// initialize maximum  ` `        ``// perimeter as 0. ` `        ``int` `maxi = 0; ` `     `  `        ``// pick up 3 different elements ` `        ``// from the array. ` `        ``for` `(``int` `i = 0; i < n - 2; i++) ` `        ``{ ` `            ``for` `(``int` `j = i + 1; j < n - 1; j++) ` `            ``{ ` `                ``for` `(``int` `k = j + 1; k < n; k++)  ` `                ``{ ` `     `  `                    ``// a, b, c are 3 sides of ` `                    ``// the triangle ` `                    ``int` `a = arr[i]; ` `                    ``int` `b = arr[j]; ` `                    ``int` `c = arr[k]; ` `     `  `                    ``// check whether a, b, c  ` `                    ``// forms a triangle or not. ` `                    ``if` `(a < b + c &&  ` `                        ``b < c + a &&  ` `                        ``c < a + b) ` `                    ``{ ` `     `  `                        ``// if it forms a triangle ` `                        ``// then update the maximum  ` `                        ``// value. ` `                        ``maxi = Math.Max(maxi, a + b + c); ` `                    ``} ` `                ``} ` `            ``} ` `        ``} ` `     `  `        ``// If maximum perimeter is  ` `        ``// non-zero then print it. ` `        ``if` `(maxi > 0)  ` `        ``Console.WriteLine(``"Maximum Perimeter is: "``+ maxi); ` `     `  `        ``// otherwise no triangle  ` `        ``// formation is possible. ` `        ``else` `        ``Console.WriteLine(``"Triangle formation "``+  ` `                          ``"is not possible."``); ` `    ``} ` `     `  `    ``// Driver Code ` `    ``public` `static` `void` `Main () ` `    ``{ ` `         `  `        ``// test case 1 ` `        ``int` `[]arr1 = {6, 1, 6,  ` `                      ``5, 8, 4}; ` `        ``maxPerimeter(arr1, 6); ` `     `  `        ``// test case 2 ` `        ``int` `[]arr2 = {2, 20, 7, 55,  ` `                      ``1, 33, 12, 4}; ` `        ``maxPerimeter(arr2, 8); ` `     `  `        ``// test case 3 ` `        ``int` `[]arr3 = {33, 6, 20, 1, 8, ` `                      ``12, 5, 55, 4, 9}; ` `        ``maxPerimeter(arr3, 10); ` `    ``} ` `} ` ` `  `// This code is contributed by anuj_67. `

## PHP

 ` `

Output :

```Maximum Perimeter is: 20
Triangle formation is not possible.
Maximum Perimeter is: 41
```

Efficient Approach:
First we can sort the array in non-increasing order. So, the first element will be maximum and the last will be minimum. Now if the first 3 elements of this sorted array forms a triangle then it will be the maximum perimeter triangle, as for all other combination the sum of elements(i.e. the perimeter of that triangle) will be = b >= c). a, b,c can not form a triangle, so a >= b + c. As, b and c = c+d (if we drop b and take d) or a >= b+d (if we drop c and take d). So, we have to drop a and pick up d.
Again same set of analysis for b, c and d. We can continue this till last and whenever we find a triangle forming triple then we can stop checking, as this triple gives maximum perimeter.
Hence, if arr[i] < arr[i+1] + arr[i+2] (0 <= i <= n-3)in the sorted array then arr[i], arr[i+1] and arr[i+2] forms a triangle.
Below is the simple implementation of this concept:

## C++

 `// Efficient solution to find ` `// out maximum perimeter triangle which ` `// can be formed using the elements ` `// of the given array ` `#include ` `#include ` ` `  `using` `namespace` `std; ` ` `  `// Function to find out maximum perimeter ` `void` `maxPerimeter(``int` `arr[], ``int` `n){ ` ` `  `    ``// sort the array elements ` `    ``// in reversed order ` `    ``sort(arr, arr+n, greater<``int``>()); ` ` `  `    ``// initialize maximum ` `    ``// perimeter to 0 ` `    ``int` `maxi = 0; ` ` `  `    ``// loop through the sorted array ` `    ``// and check whether it forms a ` `    ``// triangle or not. ` `    ``for` `(``int` `i = 0; i < n-2; i++){ ` ` `  `        ``// Check whether arr[i], arr[i+1] ` `        ``// and arr[i+2] forms a triangle ` `        ``// or not. ` `        ``if` `(arr[i] < arr[i+1] + arr[i+2]){ ` ` `  `            ``// if it forms a triangle then ` `            ``// it is the triangle with ` `            ``// maximum perimeter. ` `            ``maxi = max(maxi, arr[i] + arr[i+1] + arr[i+2]); ` `            ``break``; ` `        ``} ` `    ``} ` ` `  `    ``// If maximum perimeter is non-zero ` `    ``// then print it. ` `    ``if` `(maxi) ` `        ``cout << ``"Maximum Perimeter is: "` `        ``<< maxi << endl; ` ` `  `    ``// otherwise no triangle formation ` `    ``// is possible. ` `    ``else` `        ``cout << ``"Triangle formation"` `        ``<< ``"is not possible."` `<< endl; ` `} ` ` `  `// Driver Program ` `int` `main() ` `{ ` `    ``// test case 1 ` `    ``int` `arr1[6] = {6, 1, 6, 5, 8, 4}; ` `    ``maxPerimeter(arr1, 6); ` ` `  `    ``// test case 2 ` `    ``int` `arr2[8] = {2, 20, 7, 55, 1, ` `                    ``33, 12, 4}; ` `    ``maxPerimeter(arr2, 8); ` ` `  `    ``// test case 3 ` `    ``int` `arr3[10] = {33, 6, 20, 1, 8, ` `                    ``12, 5, 55, 4, 9}; ` `    ``maxPerimeter(arr3, 10); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Efficient solution to find  ` `// out maximum perimeter triangle which  ` `// can be formed using the elements  ` `// of the given array  ` ` `  `import` `java.util.Arrays; ` ` `  `class` `GFG { ` ` `  `// Function to find out maximum perimeter  ` `    ``static` `void` `maxPerimeter(``int` `arr[], ``int` `n) { ` ` `  `        ``// sort the array elements  ` `        ``// in reversed order  ` `        ``arr = arrRevSort(arr); ` `        ``//sort(arr, arr+n, greater());  ` ` `  `        ``// initialize maximum  ` `        ``// perimeter to 0  ` `        ``int` `maxi = ``0``; ` ` `  `        ``// loop through the sorted array  ` `        ``// and check whether it forms a  ` `        ``// triangle or not.  ` `        ``for` `(``int` `i = ``0``; i < n - ``2``; i++) { ` ` `  `            ``// Check whether arr[i], arr[i+1]  ` `            ``// and arr[i+2] forms a triangle  ` `            ``// or not.  ` `            ``if` `(arr[i] < arr[i + ``1``] + arr[i + ``2``]) { ` ` `  `                ``// if it forms a triangle then  ` `                ``// it is the triangle with  ` `                ``// maximum perimeter.  ` `                ``maxi = Math.max(maxi, arr[i] + arr[i + ``1``] + arr[i + ``2``]); ` `                ``break``; ` `            ``} ` `        ``} ` ` `  `        ``// If maximum perimeter is non-zero  ` `        ``// then print it.  ` `        ``if` `(maxi > ``0``) { ` `            ``System.out.println(``"Maximum Perimeter is: "` `+ maxi); ` `        ``} ``// otherwise no triangle formation  ` `        ``// is possible.  ` `        ``else` `{ ` `            ``System.out.println(``"Triangle formation is not possible."``); ` `        ``} ` `    ``} ` `    ``//Function return sorted array in Decreasing  ` ` `  `    ``static` `int``[] arrRevSort(``int``[] arr) { ` `        ``Arrays.sort(arr, ``0``, arr.length); ` `        ``int` `j = arr.length - ``1``; ` `        ``for` `(``int` `i = ``0``; i < arr.length / ``2``; i++, j--) { ` `            ``int` `temp = arr[i]; ` `            ``arr[i] = arr[j]; ` `            ``arr[j] = temp; ` `        ``} ` `        ``return` `arr; ` `    ``} ` ` `  `// Driver Program  ` `    ``public` `static` `void` `main(String[] args) { ` `        ``// test case 1  ` `        ``int` `arr1[] = {``6``, ``1``, ``6``, ``5``, ``8``, ``4``}; ` `        ``maxPerimeter(arr1, ``6``); ` ` `  `        ``// test case 2  ` `        ``int` `arr2[] = {``2``, ``20``, ``7``, ``55``, ``1``, ``33``, ``12``, ``4``}; ` `        ``maxPerimeter(arr2, ``8``); ` ` `  `        ``// test case 3  ` `        ``int` `arr3[] = {``33``, ``6``, ``20``, ``1``, ``8``, ``12``, ``5``, ``55``, ``4``, ``9``}; ` `        ``maxPerimeter(arr3, ``10``); ` `    ``} ` `} ` `/*This Java code is contributed by 29AjayKumar*/`

## Python3

 `# Efficient solution to find ` `# out maximum perimeter triangle which ` `# can be formed using the elements ` `# of the given array ` ` `  `# Function to find the  ` `# maximum perimeter ` `def` `maxPerimeter(arr): ` `    ``maxi ``=` `0` `    ``n ``=` `len``(arr) ` `    ``arr.sort(reverse ``=` `True``) ` ` `  `    ``for` `i ``in` `range``(``0``, n ``-` `2``): ` `        ``if` `arr[i] < (arr[i ``+` `1``] ``+` `arr[i ``+` `2``]): ` `            ``maxi ``=` `max``(maxi, arr[i] ``+`  `                       ``arr[i ``+` `1``] ``+` `arr[i ``+` `2``]) ` `            ``break` ` `  `    ``if``(maxi ``=``=` `0``): ` `        ``return` `"Triangle formation is not possible"` `    ``else``: ` `        ``return` `"Maximum Perimeter is: "``+` `str``(maxi) ` ` `  `# Driver Code ` `def` `main(): ` `    ``arr1 ``=` `[``6``, ``1``, ``6``, ``5``, ``8``, ``4``] ` `    ``a ``=` `maxPerimeter(arr1) ` `    ``print``(a) ` ` `  `    ``arr2 ``=` `[``2``, ``20``, ``7``, ``55``,  ` `            ``1``, ``33``, ``12``, ``4``] ` `    ``a ``=` `maxPerimeter(arr2) ` `    ``print``(a) ` ` `  `    ``arr3 ``=` `[``33``, ``6``, ``20``, ``1``, ``8``, ` `            ``12``, ``5``, ``55``, ``4``, ``9``] ` `    ``a ``=` `maxPerimeter(arr3) ` `    ``print``(a) ` ` `  `if` `__name__``=``=``'__main__'``: ` `    ``main() ` ` `  `# This code is contributed  ` `# by Pritha Upadhyay `

## C#

 `// Efficient solution to find  ` `// out maximum perimeter triangle which  ` `// can be formed using the elements  ` `// of the given array  ` ` `  `using` `System; ` ` `  `class` `GFG { ` ` `  `// Function to find out maximum perimeter  ` `    ``static` `void` `maxPerimeter(``int``[] arr, ``int` `n) { ` ` `  `        ``// sort the array elements  ` `        ``// in reversed order  ` `        ``arr = arrRevSort(arr); ` `        ``//sort(arr, arr+n, greater());  ` ` `  `        ``// initialize maximum  ` `        ``// perimeter to 0  ` `        ``int` `maxi = 0; ` ` `  `        ``// loop through the sorted array  ` `        ``// and check whether it forms a  ` `        ``// triangle or not.  ` `        ``for` `(``int` `i = 0; i < n - 2; i++) { ` ` `  `            ``// Check whether arr[i], arr[i+1]  ` `            ``// and arr[i+2] forms a triangle  ` `            ``// or not.  ` `            ``if` `(arr[i] < arr[i + 1] + arr[i + 2]) { ` ` `  `                ``// if it forms a triangle then  ` `                ``// it is the triangle with  ` `                ``// maximum perimeter.  ` `                ``maxi = Math.Max(maxi, arr[i] + arr[i + 1] + arr[i + 2]); ` `                ``break``; ` `            ``} ` `        ``} ` ` `  `        ``// If maximum perimeter is non-zero  ` `        ``// then print it.  ` `        ``if` `(maxi > 0) { ` `            ``Console.WriteLine(``"Maximum Perimeter is: "` `+ maxi); ` `        ``} ``// otherwise no triangle formation  ` `        ``// is possible.  ` `        ``else` `{ ` `            ``Console.WriteLine(``"Triangle formation is not possible."``); ` `        ``} ` `    ``} ` `    ``//Function return sorted array in Decreasing  ` ` `  `    ``static` `int``[] arrRevSort(``int``[] arr) { ` `        ``Array.Sort(arr); ` `        ``int` `j = arr.Length - 1; ` `        ``for` `(``int` `i = 0; i < arr.Length / 2; i++, j--) { ` `            ``int` `temp = arr[i]; ` `            ``arr[i] = arr[j]; ` `            ``arr[j] = temp; ` `        ``} ` `        ``return` `arr; ` `    ``} ` ` `  `// Driver Program  ` `    ``public` `static` `void` `Main() { ` `        ``// test case 1  ` `        ``int``[] arr1 = {6, 1, 6, 5, 8, 4}; ` `        ``maxPerimeter(arr1, 6); ` ` `  `        ``// test case 2  ` `        ``int``[] arr2 = {2, 20, 7, 55, 1, 33, 12, 4}; ` `        ``maxPerimeter(arr2, 8); ` ` `  `        ``// test case 3  ` `        ``int``[] arr3 = {33, 6, 20, 1, 8, 12, 5, 55, 4, 9}; ` `        ``maxPerimeter(arr3, 10); ` `    ``} ` `} ` `/*This Java code is contributed by mits*/`

## PHP

 ` `

Output :

```Maximum Perimeter is: 20
Triangle formation is not possible.
Maximum Perimeter is: 41
```

Time complexity of this approach is O(n*log(n)). This much time is required to sort the array.

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

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 Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :

Be the First to upvote.

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