Skip to content
Related Articles

Related Articles

Improve Article

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 <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)




My Personal Notes arrow_drop_up
Recommended Articles
Page :