# Maximum size of subset of given array such that a triangle can be formed by any three integers as the sides of the triangle

Given an array **arr[]** consisting of **N** integers, the task is to find the size of the largest subset of the array such that a triangle can be formed from any of the three integers of the subset as the sides of a triangle.

**Examples:**

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**.

Input:arr[] = {1, 4, 7, 4}Output:3Explanation:A possible subsets that follow the given conditions are {1, 4, 4} and {4, 4, 7}. The size of both of these subsets is 3 which is the maximum possible.

Input:arr[] = {2, 7, 4, 1, 6, 9, 5, 3}Output:4

**Approach:** The given problem can be solved with the help of the Greedy Approach using the Sliding Window Technique. It is known that for a triangle having side lengths** A**, **B**, and** C**, **A + B > C** must hold true where **A** and **B** are the sides with smaller lengths. Based on the above observation the given problem can be solved using the following steps:

- Sort the given array arr[] in non-decreasing order.
- Maintain two variables
**i**and**j**where**i**keep track of the starting point of the current window and**j**keep track of the ending point of the current window. Initially**i = 0**and**j = i + 2**. - Increment the value of
**j**until**arr[i] + arr[i+1] > arr[j]**and keep track of the maximum value of**j – i**in a variable**maxSize**. If**arr[i] + arr[i+1] > arr[j]**, increment the value of**i**by**1**. - Follow the above step till the whole array has been traversed.
- After completing the above steps, the value stored in
**maxSize**is the required result.

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to find the maximum size of` `// the subset of the given array such` `// that a triangle can be formed from any` `// three integers of the subset as sides` `int` `maximizeSubset(` `int` `arr[], ` `int` `N)` `{` ` ` `// Sort arr[] in increasing order` ` ` `sort(arr, arr + N);` ` ` `// Stores the maximum size of a valid` ` ` `// subset of the given array` ` ` `int` `maxSize = 0;` ` ` `// Stores the starting index of the` ` ` `// current window` ` ` `int` `i = 0;` ` ` `// Stores the last index of the` ` ` `// current window` ` ` `int` `j = i + 2;` ` ` `// Iterate over the array arr[]` ` ` `while` `(i < N - 2) {` ` ` `// Increment j till the value` ` ` `// of arr[i] + arr[i + 1] >` ` ` `// arr[j] holds true` ` ` `while` `(arr[i] + arr[i + 1] > arr[j]) {` ` ` `j++;` ` ` `}` ` ` `// Update the value of maxSize` ` ` `maxSize = max(maxSize, j - i);` ` ` `i++;` ` ` `j = max(j, i + 2);` ` ` `}` ` ` `// Return Answer` ` ` `return` `maxSize;` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `arr[] = { 2, 7, 4, 1, 6, 9, 5, 3 };` ` ` `int` `N = ` `sizeof` `(arr) / ` `sizeof` `(arr[0]);` ` ` `cout << maximizeSubset(arr, N) << endl;` ` ` `return` `0;` `}` |

## Java

`// Java program for the above approach` `import` `java.util.*;` `class` `GFG{` `// Function to find the maximum size of` `// the subset of the given array such` `// that a triangle can be formed from any` `// three integers of the subset as sides` `static` `int` `maximizeSubset(` `int` `arr[], ` `int` `N)` `{` ` ` ` ` `// Sort arr[] in increasing order` ` ` `Arrays.sort(arr);` ` ` `// Stores the maximum size of a valid` ` ` `// subset of the given array` ` ` `int` `maxSize = ` `0` `;` ` ` `// Stores the starting index of the` ` ` `// current window` ` ` `int` `i = ` `0` `;` ` ` `// Stores the last index of the` ` ` `// current window` ` ` `int` `j = i + ` `2` `;` ` ` `// Iterate over the array arr[]` ` ` `while` `(i < N - ` `2` `) {` ` ` `// Increment j till the value` ` ` `// of arr[i] + arr[i + 1] >` ` ` `// arr[j] holds true` ` ` ` ` `while` `(j<N && arr[i] + arr[i + ` `1` `] > arr[j]) {` ` ` `j++;` ` ` `}` ` ` `// Update the value of maxSize` ` ` `maxSize = Math.max(maxSize, j - i);` ` ` `i++;` ` ` `j = Math.max(j, i + ` `2` `);` ` ` `}` ` ` `// Return Answer` ` ` `return` `maxSize;` `}` `// Driver Code` `public` `static` `void` `main(String[] args)` `{` ` ` `int` `arr[] = { ` `2` `, ` `7` `, ` `4` `, ` `1` `, ` `6` `, ` `9` `, ` `5` `, ` `3` `};` ` ` `int` `N = arr.length;` ` ` `System.out.print(maximizeSubset(arr, N) +` `"\n"` `);` `}` `}` `// This code is contributed by 29AjayKumar` |

## Python3

`# python program for the above approach` `# Function to find the maximum size of` `# the subset of the given array such` `# that a triangle can be formed from any` `# three integers of the subset as sides` `def` `maximizeSubset(arr, N):` ` ` `# Sort arr[] in increasing order` ` ` `arr.sort()` ` ` `# Stores the maximum size of a valid` ` ` `# subset of the given array` ` ` `maxSize ` `=` `0` ` ` `# Stores the starting index of the` ` ` `# current window` ` ` `i ` `=` `0` ` ` `# Stores the last index of the` ` ` `# current window` ` ` `j ` `=` `i ` `+` `2` ` ` `# Iterate over the array arr[]` ` ` `while` `(i < N ` `-` `2` `):` ` ` `# Increment j till the value` ` ` `# of arr[i] + arr[i + 1] >` ` ` `# arr[j] holds true` ` ` `while` `(j < N ` `and` `arr[i] ` `+` `arr[i ` `+` `1` `] > arr[j]):` ` ` `j ` `=` `j ` `+` `1` ` ` `# Update the value of maxSize` ` ` `maxSize ` `=` `max` `(maxSize, j ` `-` `i)` ` ` `i ` `+` `=` `1` ` ` `j ` `=` `max` `(j, i ` `+` `2` `)` ` ` `# Return Answer` ` ` `return` `maxSize` `# Driver Code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` `arr ` `=` `[` `2` `, ` `7` `, ` `4` `, ` `1` `, ` `6` `, ` `9` `, ` `5` `, ` `3` `]` ` ` `N ` `=` `len` `(arr)` ` ` `print` `(maximizeSubset(arr, N))` ` ` `# This code is contributed by rakeshsahni` |

## C#

`// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG{` `// Function to find the maximum size of` `// the subset of the given array such` `// that a triangle can be formed from any` `// three integers of the subset as sides` `static` `int` `maximizeSubset(` `int` `[]arr, ` `int` `N)` `{` ` ` `// Sort arr[] in increasing order` ` ` `Array.Sort(arr);` ` ` `// Stores the maximum size of a valid` ` ` `// subset of the given array` ` ` `int` `maxSize = 0;` ` ` `// Stores the starting index of the` ` ` `// current window` ` ` `int` `i = 0;` ` ` `// Stores the last index of the` ` ` `// current window` ` ` `int` `j = i + 2;` ` ` `// Iterate over the array arr[]` ` ` `while` `(i < N - 2) {` ` ` `// Increment j till the value` ` ` `// of arr[i] + arr[i + 1] >` ` ` `// arr[j] holds true` ` ` `if` `(j>=N || i+1 >=N)` ` ` `break` `;` ` ` `while` `(j<N && arr[i] + arr[i + 1] > arr[j]) {` ` ` `j++;` ` ` `}` ` ` `// Update the value of maxSize` ` ` `maxSize = Math.Max(maxSize, j - i);` ` ` ` ` `i++;` ` ` `j = Math.Max(j, i + 2);` ` ` `}` ` ` `// Return Answer` ` ` `return` `maxSize;` `}` `// Driver Code` `public` `static` `void` `Main()` `{` ` ` `int` `[]arr = { 2, 7, 4, 1, 6, 9, 5, 3 };` ` ` `int` `N = arr.Length;` ` ` `Console.Write(maximizeSubset(arr, N));` `}` `}` `// This code is contributed by SURENDRA_GANGWAR.` |

## Javascript

`<script>` ` ` `// JavaScript program for the above approach` ` ` `// Function to find the maximum size of` ` ` `// the subset of the given array such` ` ` `// that a triangle can be formed from any` ` ` `// three integers of the subset as sides` ` ` `const maximizeSubset = (arr, N) => {` ` ` `// Sort arr[] in increasing order` ` ` `arr.sort((a, b) => a - b)` ` ` `// Stores the maximum size of a valid` ` ` `// subset of the given array` ` ` `let maxSize = 0;` ` ` `// Stores the starting index of the` ` ` `// current window` ` ` `let i = 0;` ` ` `// Stores the last index of the` ` ` `// current window` ` ` `let j = i + 2;` ` ` `// Iterate over the array arr[]` ` ` `while` `(i < N - 2) {` ` ` `// Increment j till the value` ` ` `// of arr[i] + arr[i + 1] >` ` ` `// arr[j] holds true` ` ` `while` `(arr[i] + arr[i + 1] > arr[j]) {` ` ` `j++;` ` ` `}` ` ` `// Update the value of maxSize` ` ` `maxSize = Math.max(maxSize, j - i);` ` ` `i++;` ` ` `j = Math.max(j, i + 2);` ` ` `}` ` ` `// Return Answer` ` ` `return` `maxSize;` ` ` `}` ` ` `// Driver Code` ` ` `let arr = [2, 7, 4, 1, 6, 9, 5, 3];` ` ` `let N = arr.length;` ` ` `document.write(maximizeSubset(arr, N));` ` ` `// This code is contributed by rakeshsahni` `</script>` |

**Output:**

4

**Time Complexity:** O(N*log N)**Auxiliary Space:** O(1)