Count of subsets having sum of min and max element less than K

• Difficulty Level : Medium
• Last Updated : 16 Jan, 2022

Given an integer array arr[] and an integer K, the task is to find the number of non-empty subsets S such that min(S) + max(S) < K.
Examples:

Input: arr[] = {2, 4, 5, 7} K = 8
Output: 4
Explanation:
The possible subsets are {2}, {2, 4}, {2, 4, 5} and {2, 5}
Input:: arr[] = {2, 4, 2, 5, 7} K = 10
Output: 26

Approach

• Sort the input array first.
• Now use Two Pointer Technique to count the number of subsets.
• Let take two pointers left and right and set left = 0 and right = N-1.

if (arr[left] + arr[right] < K )
Increment the left pointer by 1 and add 2 j – i into answer, because the left and right values make up a potential end values of a subset. All the values from [i, j – 1] also make up end of subsets which will have the sum < K. So, we need to calculate all the possible subsets for left = i and right ∊ [i, j]. So, after summing up values 2 j – i + 1 + 2 j – i – 2 + … + 2 0 of the GP, we get 2 j – i
if( arr[left] + arr[right] >= K )
Decrement the right pointer by 1.

• Repeat the below process until left <= right.

Below is the implementation of the above approach:

C++

 // C++ program to print count// of subsets S such that// min(S) + max(S) < K #include using namespace std; // Function that return the// count of subset such that// min(S) + max(S) < Kint get_subset_count(int arr[], int K,                     int N){    // Sorting the array    sort(arr, arr + N);     int left, right;    left = 0;    right = N - 1;     // ans stores total number of subsets    int ans = 0;     while (left <= right) {        if (arr[left] + arr[right] < K) {             // add all possible subsets            // between i and j            ans += 1 << (right - left);            left++;        }        else {            // Decrease the sum            right--;        }    }    return ans;} // Driver codeint main(){    int arr[] = { 2, 4, 5, 7 };    int K = 8;    int N = sizeof(arr) / sizeof(arr);    cout << get_subset_count(arr, K, N);    return 0;}

Java

 // Java program to print count// of subsets S such that// Math.min(S) + Math.max(S) < Kimport java.util.*; class GFG{ // Function that return the// count of subset such that// Math.min(S) + Math.max(S) < Kstatic int get_subset_count(int arr[], int K,                                       int N){         // Sorting the array    Arrays.sort(arr);     int left, right;    left = 0;    right = N - 1;     // ans stores total number    // of subsets    int ans = 0;     while (left <= right)    {        if (arr[left] + arr[right] < K)        {             // Add all possible subsets            // between i and j            ans += 1 << (right - left);            left++;        }        else        {                         // Decrease the sum            right--;        }    }    return ans;} // Driver codepublic static void main(String[] args){    int arr[] = { 2, 4, 5, 7 };    int K = 8;    int N = arr.length;         System.out.print(get_subset_count(arr, K, N));}} // This code is contributed by Rajput-Ji

Python3

 # Python3 program to print# count of subsets S such# that min(S) + max(S) < K # Function that return the# count of subset such that# min(S) + max(S) < Kdef get_subset_count(arr, K, N):     # Sorting the array    arr.sort()     left = 0;    right = N - 1;     # ans stores total number of subsets    ans = 0;     while (left <= right):        if (arr[left] + arr[right] < K):                         # Add all possible subsets            # between i and j            ans += 1 << (right - left);            left += 1;        else:                         # Decrease the sum            right -= 1;         return ans; # Driver codearr = [ 2, 4, 5, 7 ];K = 8; print(get_subset_count(arr, K, 4)) # This code is contributed by grand_master

C#

 // C# program to print count// of subsets S such that// Math.Min(S) + Math.Max(S) < Kusing System; class GFG{ // Function that return the// count of subset such that// Math.Min(S) + Math.Max(S) < Kstatic int get_subset_count(int []arr, int K,                                       int N){         // Sorting the array    Array.Sort(arr);     int left, right;    left = 0;    right = N - 1;     // ans stores total number    // of subsets    int ans = 0;     while (left <= right)    {        if (arr[left] + arr[right] < K)        {                         // Add all possible subsets            // between i and j            ans += 1 << (right - left);            left++;        }        else        {                         // Decrease the sum            right--;        }    }    return ans;} // Driver codepublic static void Main(String[] args){    int []arr = { 2, 4, 5, 7 };    int K = 8;    int N = arr.Length;         Console.Write(get_subset_count(arr, K, N));}} // This code is contributed by gauravrajput1

Javascript


Output:
4

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

My Personal Notes arrow_drop_up