Related Articles

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

• Last Updated : 13 Oct, 2021

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: 3
Explanation: 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 ``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);` `    ``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 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 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

 ``
Output:
`4`

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

My Personal Notes arrow_drop_up