Related Articles

# Check if all K-length subset sums of first array greater than that of the second array

• Last Updated : 18 May, 2021

Given two arrays A[] and B[] of size N and an integer K, the task is to check if all possible subset-sums of subsets of size K of the array A[] are greater than that of the array B[] or not. If found to be true, then print “YES”. Otherwise, print “NO”.

Examples:

Input: A[] = {12, 11, 10, 13}, B[] = {7, 10, 6, 2}, K = 3
Output: YES
Explanation: All possible subset sum of size K(= 3) in A[] are {33, 36, 35, 34}.
All possible subset sum of size K(= 3) in B[] are {23, 19, 15, 18}.
Since all subset-sums of size K in the array A[] is greater than all possible subset-sums of size K in the array B[], the required output is “YES”.

Input : A[] = {5, 3, 3, 4, 4, 6, 1}, B[] = {9, 10, 9, 8, 4, 6, 2}, K = 6
Output : NO

Naive Approach: The simplest approach to solve this problem is to generate all possible subsets of size K from the arrays A[] and B[] and calculate their respective sums. Check if all the sums obtained in array A[] exceeds that of array B[] or not. If found to be true, then print “YES”. Otherwise, print “NO”.

Time Complexity: O(K × N2K)
Auxiliary Space: O(NK)

Efficient Approach: To optimize the above approach, the idea is based on the fact that if the smallest subset-sum of size K of the array A[] is greater than the largest subset-sum of size K of the array B[], then print “YES”. Otherwise, print “NO”. Follow the steps below to solve the problem:

Below is the implementation of the above approach;

## C++

 `// C++ program to implement``// the above approach` `#include ``using` `namespace` `std;` `// Function to check all subset-sums``// of K-length subsets in A[] is greater``// that that in the array B[] or not``bool` `checkSubsetSum(``int` `A[], ``int` `B[], ``int` `N,``                    ``int` `K)``{``    ``// Sort the array in``    ``// ascending order``    ``sort(A, A + N);` `    ``// Sort the array in``    ``// descending order``    ``sort(B, B + N,``         ``greater<``int``>());` `    ``// Stores sum of first K``    ``// elements of A[]``    ``int` `sum1 = 0;` `    ``// Stores sum of first K``    ``// elements of B[]``    ``int` `sum2 = 0;` `    ``// Traverse both the arrays``    ``for` `(``int` `i = 0; i < K; i++) {` `        ``// Update sum1``        ``sum1 += A[i];` `        ``// Update sum2``        ``sum2 += B[i];``    ``}` `    ``// If sum1 exceeds sum2``    ``if` `(sum1 > sum2) {``        ``return` `true``;``    ``}` `    ``return` `false``;``}` `// Driver Code``int` `main()``{``    ``int` `A[] = { 12, 11, 10, 13 };``    ``int` `B[] = { 7, 10, 6, 2 };` `    ``int` `N = ``sizeof``(A) / ``sizeof``(A);` `    ``int` `K = 3;``    ``if` `(checkSubsetSum(A, B, N, K)) {``        ``cout << ``"YES"``;``    ``}``    ``else` `{``        ``cout << ``"NO"``;``    ``}` `    ``return` `0;``}`

## Java

 `// Java program to implement``// the above approach``import` `java.util.*;``   ` `class` `GFG{``    ` `// Function reverses the elements of the array``static` `void` `reverse(``int` `myArray[])``{``    ``Collections.reverse(Arrays.asList(myArray));``}``   ` `// Function to check all subset-sums``// of K-length subsets in A[] is greater``// that that in the array B[] or not``static` `boolean` `checkSubsetSum(``int` `A[], ``int` `B[],``                              ``int` `N, ``int` `K)``{``    ` `    ``// Sort the array in``    ``// ascending order``    ``Arrays.sort(A);`` ` `    ``// Sort the array in``    ``// descending order``    ``Arrays.sort(B);``    ``reverse(B);`` ` `    ``// Stores sum of first K``    ``// elements of A[]``    ``int` `sum1 = ``0``;`` ` `    ``// Stores sum of first K``    ``// elements of B[]``    ``int` `sum2 = ``0``;`` ` `    ``// Traverse both the arrays``    ``for``(``int` `i = ``0``; i < K; i++)``    ``{``        ` `        ``// Update sum1``        ``sum1 += A[i];`` ` `        ``// Update sum2``        ``sum2 += B[i];``    ``}`` ` `    ``// If sum1 exceeds sum2``    ``if` `(sum1 > sum2)``    ``{``        ``return` `true``;``    ``}``    ``return` `false``;``}``   ` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `A[] = { ``12``, ``11``, ``10``, ``13` `};``    ``int` `B[] = { ``7``, ``10``, ``6``, ``2` `};`` ` `    ``int` `N = A.length;``    ``int` `K = ``3``;``    ` `    ``if` `(checkSubsetSum(A, B, N, K))``    ``{``        ``System.out.print(``"YES"``);``    ``}``    ``else``    ``{``        ``System.out.print(``"NO"``);``    ``}``}``}` `// This code is contributed by susmitakundugoaldanga`

## Python3

 `# Python3 program to implement``# the above approach` `# Function to check all subset-sums``# of K-length subsets in A[] is greater``# that that in the array B[] or not``def` `checkSubsetSum(A, B, N, K):``    ` `    ``# Sort the array in``    ``# ascending order``    ``A.sort()``    ` `    ``# Sort the array in``    ``# descending order``    ``B.sort(reverse ``=` `True``)``    ` `    ``# Stores sum of first K``    ``# elements of A[]``    ``sum1 ``=` `0``    ` `    ``# Stores sum of first K``    ``# elements of B[]``    ``sum2 ``=` `0` `    ``# Traverse both the arrays``    ``for` `i ``in` `range``(K):``        ` `        ``# Update sum1``        ``sum1 ``+``=` `A[i]``        ` `        ``# Update sum2``        ``sum2 ``+``=` `B[i]``        ` `    ``# If sum1 exceeds sum2``    ``if` `(sum1 > sum2):``        ``return` `True``        ` `    ``return` `False` `# Driver Code``A ``=` `[ ``12``, ``11``, ``10``, ``13` `]``B ``=` `[ ``7``, ``10``, ``6``, ``2``]` `N ``=` `len``(A)``K ``=` `3` `if` `(checkSubsetSum(A, B, N, K)):``    ``print``(``"Yes"``)``else``:``    ``print``(``"No"``)` `# This code is contributed by avanitrachhadiya2155`

## C#

 `// C# program to implement``// the above approach``using` `System;` `public` `class` `GFG{``    ` `// Function reverses the elements of the array``static` `void` `reverse(``int` `[]myArray)``{``    ``Array.Sort(myArray);``    ``Array.Reverse(myArray);``}``   ` `// Function to check all subset-sums``// of K-length subsets in []A is greater``// that that in the array []B or not``static` `bool` `checkSubsetSum(``int` `[]A, ``int` `[]B,``                              ``int` `N, ``int` `K)``{``    ` `    ``// Sort the array in``    ``// ascending order``    ``Array.Sort(A);`` ` `    ``// Sort the array in``    ``// descending order``    ``Array.Sort(B);``    ``reverse(B);`` ` `    ``// Stores sum of first K``    ``// elements of []A``    ``int` `sum1 = 0;`` ` `    ``// Stores sum of first K``    ``// elements of []B``    ``int` `sum2 = 0;`` ` `    ``// Traverse both the arrays``    ``for``(``int` `i = 0; i < K; i++)``    ``{``        ` `        ``// Update sum1``        ``sum1 += A[i];`` ` `        ``// Update sum2``        ``sum2 += B[i];``    ``}`` ` `    ``// If sum1 exceeds sum2``    ``if` `(sum1 > sum2)``    ``{``        ``return` `true``;``    ``}``    ``return` `false``;``}``   ` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]A = { 12, 11, 10, 13 };``    ``int` `[]B = { 7, 10, 6, 2 };`` ` `    ``int` `N = A.Length;``    ``int` `K = 3;``    ` `    ``if` `(checkSubsetSum(A, B, N, K))``    ``{``        ``Console.Write(``"YES"``);``    ``}``    ``else``    ``{``        ``Console.Write(``"NO"``);``    ``}``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``
Output:
`YES`

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

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.

My Personal Notes arrow_drop_up