Skip to content
Related Articles

Related Articles

Improve Article

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 <bits/stdc++.h>
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[0]);
 
    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




<script>
 
// JavaScript 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
function checkSubsetSum(A, B, N, K)
{
    // Sort the array in
    // ascending order
    A.sort((a,b)=> a-b);
 
    // Sort the array in
    // descending order
    B.sort((a,b)=>b-a);
 
    // Stores sum of first K
    // elements of A[]
    var sum1 = 0;
 
    // Stores sum of first K
    // elements of B[]
    var sum2 = 0;
 
    // Traverse both the arrays
    for (var 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
var A = [12, 11, 10, 13];
var B = [7, 10, 6, 2];
var N = A.length;
var K = 3;
if (checkSubsetSum(A, B, N, K)) {
    document.write( "YES");
}
else {
    document.write( "NO");
}
 
</script>
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
Recommended Articles
Page :