Sum of length of two smallest subsets possible from a given array with sum at least K
Last Updated :
06 Apr, 2023
Given an array arr[] consisting of N integers and an integer K, the task is to find the sum of the length of the two smallest unique subsets having sum of its elements at least K.
Examples:
Input: arr[] = {2, 4, 5, 6, 7, 8}, K = 16
Output: 6
Explanation:
The subsets {2, 6, 8} and {4, 5, 7} are the two smallest subsets with sum K(= 16).
Therefore, the sum of the lengths of both these subsets = 3 + 3 = 6.
Input: arr[] = {14, 3, 7, 8, 9, 7, 12, 15, 10, 6}, K = 40
Output: 8
Approach: The given problem can be solved based on the following observations:
- Sorting the array reduces the problem to choosing a subarray whose sum is at least K between the range of indices [i, N], and then check, if the sum of the remaining array elements in the range of indices [i, N] is K or not.
- To implement the above idea, a 2D array, say dp[][], is used such that dp[i][j] stores the minimum sum of the subset over the range of indices [i, N] having a value at least j. Then the transition state is similar to 0/1 Knapsack that can be defined as:
- If the value of arr[i] is greater than j, then update dp[i][j] to arr[i].
- Otherwise, update dp[i][j] to the minimum of dp[i + 1][j] and (dp[i + 1][j – arr[i]] + arr[i]).
Follow the steps below to solve the problem:
- Sort the array in ascending order.
- Initialize an array, say suffix[], and store the suffix sum of the array arr[] in it.
- Initialize a 2D array, say dp[][], such that dp[i][j] stores the minimum sum of the subset over the range of indices [i, N] having a value at least j.
- Initialize dp[N][0] as 0 and all other states as INT_MAX.
- Traverse the array arr[i] in reverse order and perform the following steps:
- Iterate over the range of indices [0, K] in reverse order and perform the following operations:
- If the value of arr[i] is at least j, then update the value of dp[i][j] as arr[i] as the current state has sum at least j. Now, continue the iteration.
- If the value of next state, i.e., dp[i + 1][j – arr[i]] is INT_MAX, then update dp[i][j] as INT_MAX.
- Otherwise, update dp[i][j] as the minimum of dp[i + 1][j] and (dp[i + 1][j – arr[i]] + arr[i]) to store the sum of all values having sum at least j.
- Now, traverse the array suffix[] in reverse order and if the value of (suffix[i] – dp[i][K]) is at least K, then print (N – i) as the sum of the size of the two smallest subsets formed and break out of the loop.
- Otherwise, print “-1”.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e9;
int MinimumLength( int A[], int N, int K)
{
sort(A, A + N);
int suffix[N + 1] = { 0 };
for ( int i = N - 1; i >= 0; i--)
suffix[i] = suffix[i + 1] + A[i];
int dp[N + 1][K + 1];
for ( int i = 0; i <= N; i++)
for ( int j = 0; j <= K; j++)
dp[i][j] = MAX;
dp[N][0] = 0;
for ( int i = N - 1; i >= 0; i--) {
for ( int j = K; j >= 0; j--) {
if (j <= A[i]) {
dp[i][j] = A[i];
continue ;
}
if (dp[i + 1][j - A[i]] == MAX)
dp[i][j] = MAX;
else
dp[i][j] = min(dp[i + 1][j],
dp[i + 1][j - A[i]] + A[i]);
}
}
for ( int i = N - 1; i >= 0; i--) {
if (suffix[i] - dp[i][K] >= K) {
return N - i;
}
}
return -1;
}
int main()
{
int arr[] = { 7, 4, 5, 6, 8 };
int K = 13;
int N = sizeof (arr) / sizeof (arr[0]);
cout << MinimumLength(arr, N, K);
return 0;
}
|
Java
import java.io.*;
import java.lang.*;
import java.util.*;
class GFG{
static int MAX = ( int )(1e9);
static int MinimumLength( int A[], int N, int K)
{
Arrays.sort(A);
int suffix[] = new int [N + 1 ];
for ( int i = N - 1 ; i >= 0 ; i--)
suffix[i] = suffix[i + 1 ] + A[i];
int dp[][] = new int [N + 1 ][K + 1 ];
for ( int i = 0 ; i <= N; i++)
for ( int j = 0 ; j <= K; j++)
dp[i][j] = MAX;
dp[N][ 0 ] = 0 ;
for ( int i = N - 1 ; i >= 0 ; i--)
{
for ( int j = K; j >= 0 ; j--)
{
if (j <= A[i])
{
dp[i][j] = A[i];
continue ;
}
if (dp[i + 1 ][j - A[i]] == MAX)
dp[i][j] = MAX;
else
dp[i][j] = Math.min(dp[i + 1 ][j],
dp[i + 1 ][j - A[i]]
+ A[i]);
}
}
for ( int i = N - 1 ; i >= 0 ; i--)
{
if (suffix[i] - dp[i][K] >= K)
{
return N - i;
}
}
return - 1 ;
}
public static void main(String[] args)
{
int arr[] = { 7 , 4 , 5 , 6 , 8 };
int K = 13 ;
int N = arr.length;
System.out.println(MinimumLength(arr, N, K));
}
}
|
Python3
MAX = 1e9
def MinimumLength(A, N, K):
A.sort()
suffix = [ 0 ] * (N + 1 )
for i in range (N - 1 , - 1 , - 1 ):
suffix[i] = suffix[i + 1 ] + A[i]
dp = [[ 0 ] * (K + 1 )] * (N + 1 )
for i in range (N + 1 ):
for j in range (K + 1 ):
dp[i][j] = MAX
dp[N][ 0 ] = 0
for i in range (N - 1 , - 1 , - 1 ):
for j in range (K, - 1 , - 1 ):
if (j < = A[i]) :
dp[i][j] = A[i]
continue
if (dp[i + 1 ][j - A[i]] = = MAX ):
dp[i][j] = MAX
else :
dp[i][j] = min (dp[i + 1 ][j],
dp[i + 1 ][j - A[i]] + A[i])
for i in range (N - 1 , - 1 , - 1 ):
if (suffix[i] - dp[i][K] > = K):
return N - i
return - 1
arr = [ 7 , 4 , 5 , 6 , 8 ]
K = 13
N = len (arr)
print (MinimumLength(arr, N, K))
|
C#
using System;
class GFG{
static int MAX = ( int )(1e9);
static int MinimumLength( int [] A, int N, int K)
{
Array.Sort(A);
int [] suffix = new int [N + 1];
for ( int i = N - 1; i >= 0; i--)
suffix[i] = suffix[i + 1] + A[i];
int [,] dp = new int [N + 1, K + 1];
for ( int i = 0; i <= N; i++)
for ( int j = 0; j <= K; j++)
dp[i, j] = MAX;
dp[N, 0] = 0;
for ( int i = N - 1; i >= 0; i--)
{
for ( int j = K; j >= 0; j--)
{
if (j <= A[i])
{
dp[i, j] = A[i];
continue ;
}
if (dp[i + 1, j - A[i]] == MAX)
dp[i, j] = MAX;
else
dp[i, j] = Math.Min(dp[i + 1, j],
dp[i + 1, j - A[i]]
+ A[i]);
}
}
for ( int i = N - 1; i >= 0; i--)
{
if (suffix[i] - dp[i, K] >= K)
{
return N - i;
}
}
return -1;
}
public static void Main( string [] args)
{
int [] arr = { 7, 4, 5, 6, 8 };
int K = 13;
int N = arr.Length;
Console.WriteLine(MinimumLength(arr, N, K));
}
}
|
Javascript
<script>
var max1 = 1000000000;
function MinimumLength(A, N, K)
{
0
A.sort();
var suffix = Array(N + 1).fill(0);
var i;
for (i = N - 1; i >= 0; i--)
suffix[i] = suffix[i + 1] + A[i];
var dp = new Array(N + 1);
for (i = 0; i < N+1; i++)
dp[i] = new Array(K + 1);
var j;
for (i = 0; i <= N; i++) {
for (j = 0; j <= K; j++){
dp[i][j] = max1;
}
};
dp[N][0] = 0;
for (i = N - 1; i >= 0; i--) {
for (j = K; j >= 0; j--) {
if (j <= A[i]) {
dp[i][j] = A[i];
continue ;
}
if (dp[i + 1][j - A[i]] == max1)
dp[i][j] = max1;
else
dp[i][j] = Math.min(dp[i + 1][j],
dp[i + 1][j - A[i]] + A[i]);
}
}
for (i = N - 1; i >= 0; i--) {
if (suffix[i] - dp[i][K] >= K) {
return N - i;
}
}
return -1;
}
var arr = [7, 4, 5, 6, 8];
var K = 13;
var N = arr.length;
document.write(MinimumLength(arr, N, K));
</script>
|
Time Complexity: O(N * K)
Auxiliary Space: O(N * K)
Efficient Approach : using array instead of 2d matrix to optimize space complexity
In previous code we can se that dp[i][j] is dependent upon dp[i+1][j-1] or dp[i][j-1] so we can assume that dp[i+1] is next and dp[i] is current row.
Implementations Steps :
- Sort the array in ascending order and calculates the suffix sum of the array.
- Initializes two vectors curr and next with a maximum possible value, where curr represents the current state, and next represents the next state.
- Set the base case of curr and next vectors as 0 for the 0th index and traverses the array from N-1 index to 0.
- For each element A[i] in the array, it iterates over the range [0, K] in reverse order and updates the curr vector by choosing the minimum length of subsets with sum greater than or equal to K. It uses the next vector to calculate the minimum value.
- Now Updates the next vector as the curr vector.
- Finally traverses the suffix sum array in reverse order and finds the sum of lengths of two smallest subsets that have sum greater than or equal to K.
- Returns the sum of lengths if it is greater than or equal to K, otherwise, it returns -1.
Implementation :
C++
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e9;
int MinimumLength( int A[], int N, int K)
{
sort(A, A + N);
int suffix[N + 1] = { 0 };
for ( int i = N - 1; i >= 0; i--)
suffix[i] = suffix[i + 1] + A[i];
vector< int >curr(K+1 , MAX);
vector< int >next(K+1 , MAX);
curr[0] = 0;
next[0] = 0;
for ( int i = N - 1; i >= 0; i--) {
for ( int j = K; j >= 0; j--) {
if (j <= A[i]) {
curr[j] = A[i];
continue ;
}
if (next[j - A[i]] == MAX)
curr[j] = MAX;
else
curr[j] = min(next[j],
next[j - A[i]] + A[i]);
}
next = curr;
}
for ( int i = N - 1; i >= 0; i--) {
if (suffix[i] - curr[K] >= K) {
return N - i;
}
}
return -1;
}
int main()
{
int arr[] = { 7, 4, 5, 6, 8 };
int K = 13;
int N = sizeof (arr) / sizeof (arr[0]);
cout << MinimumLength(arr, N, K);
return 0;
}
|
Java
import java.util.Arrays;
public class Main {
static final int MAX = ( int ) 1e9;
static int MinimumLength( int [] A, int N, int K)
{
Arrays.sort(A);
int [] suffix = new int [N + 1 ];
for ( int i = N - 1 ; i >= 0 ; i--)
suffix[i] = suffix[i + 1 ] + A[i];
int [] curr = new int [K + 1 ];
Arrays.fill(curr, MAX);
int [] next = new int [K + 1 ];
Arrays.fill(next, MAX);
curr[ 0 ] = 0 ;
next[ 0 ] = 0 ;
for ( int i = N - 1 ; i >= 0 ; i--) {
for ( int j = K; j >= 0 ; j--) {
if (j <= A[i]) {
curr[j] = A[i];
continue ;
}
if (next[j - A[i]] == MAX)
curr[j] = MAX;
else
curr[j] = Math.min(next[j],
next[j - A[i]] + A[i]);
}
next = curr.clone();
}
for ( int i = N - 1 ; i >= 0 ; i--) {
if (suffix[i] - curr[K] >= K) {
return N - i;
}
}
return - 1 ;
}
public static void main(String[] args) {
int [] arr = { 7 , 4 , 5 , 6 , 8 };
int K = 13 ;
int N = arr.length;
System.out.println(MinimumLength(arr, N, K));
}
}
|
Javascript
const MAX = 1e9;
function MinimumLength(A, N, K) {
A.sort((a, b) => a - b);
let suffix = Array(N + 1).fill(0);
for (let i = N - 1; i >= 0; i--)
suffix[i] = suffix[i + 1] + A[i];
let curr = Array(K + 1).fill(MAX);
let next = Array(K + 1).fill(MAX);
curr[0] = 0;
next[0] = 0;
for (let i = N - 1; i >= 0; i--) {
for (let j = K; j >= 0; j--) {
if (j <= A[i]) {
curr[j] = A[i];
continue ;
}
if (next[j - A[i]] == MAX)
curr[j] = MAX;
else
curr[j] = Math.min(next[j],
next[j - A[i]] + A[i]);
}
next = [...curr];
}
for (let i = N - 1; i >= 0; i--) {
if (suffix[i] - curr[K] >= K) {
return N - i;
}
}
return -1;
}
let arr = [7, 4, 5, 6, 8];
let K = 13;
let N = arr.length;
console.log(MinimumLength(arr, N, K));
|
Python3
import sys
MAX = sys.maxsize
def MinimumLength(A, N, K):
A.sort()
suffix = [ 0 ] * (N + 1 )
for i in range (N - 1 , - 1 , - 1 ):
suffix[i] = suffix[i + 1 ] + A[i]
curr = [ MAX ] * (K + 1 )
next_ = [ MAX ] * (K + 1 )
curr[ 0 ] = 0
next_[ 0 ] = 0
for i in range (N - 1 , - 1 , - 1 ):
for j in range (K, - 1 , - 1 ):
if j < = A[i]:
curr[j] = A[i]
continue
if next_[j - A[i]] = = MAX :
curr[j] = MAX
else :
curr[j] = min (next_[j],
next_[j - A[i]] + A[i])
next_ = curr.copy()
for i in range (N - 1 , - 1 , - 1 ):
if suffix[i] - curr[K] > = K:
return N - i
return - 1
if __name__ = = "__main__" :
arr = [ 7 , 4 , 5 , 6 , 8 ]
K = 13
N = len (arr)
print (MinimumLength(arr, N, K))
|
C#
using System;
using System.Collections.Generic;
using System.Linq;
public class Program
{
static int MAX = 1000000000;
static int MinimumLength( int [] A, int N, int K)
{
Array.Sort(A);
int [] suffix = new int [N + 1];
for ( int i = N - 1; i >= 0; i--)
suffix[i] = suffix[i + 1] + A[i];
List< int > curr = new List< int >(Enumerable.Repeat(MAX, K + 1));
List< int > next = new List< int >(Enumerable.Repeat(MAX, K + 1));
curr[0] = 0;
next[0] = 0;
for ( int i = N - 1; i >= 0; i--)
{
for ( int j = K; j >= 0; j--)
{
if (j <= A[i])
{
curr[j] = A[i];
continue ;
}
if (next[j - A[i]] == MAX)
curr[j] = MAX;
else
curr[j] = Math.Min(next[j], next[j - A[i]] + A[i]);
}
next = new List< int >(curr);
}
for ( int i = N - 1; i >= 0; i--)
{
if (suffix[i] - curr[K] >= K)
{
return N - i;
}
}
return -1;
}
public static void Main()
{
int [] arr = { 7, 4, 5, 6, 8 };
int K = 13;
int N = arr.Length;
Console.WriteLine(MinimumLength(arr, N, K));
}
}
|
Time Complexity: O(N * K)
Auxiliary Space: O(K)
Share your thoughts in the comments
Please Login to comment...