Minimum count of elements to be inserted in Array to form all values in [1, K] using subset sum
Last Updated :
11 Aug, 2021
Given a sorted array arr[] consisting of N integers, and an integer K, the task is to find the minimum number of elements to be inserted in the array such that any value in the range [1, K] can be formed by adding elements of any subset of the modified array.
Examples:
Input: arr[] = {1, 3}, K = 6
Output: 1
Explanation:
Adding the number 2 to the array modifies the array arr[] to {1, 2, 3}. Now, every sum value over the range [1, 6] can be formed:
- Sum = 1: The subset is {1}.
- Sum = 2: The subset is {2}.
- Sum = 3: The subset is {3}.
- Sum = 4: The subset is {1, 3}.
- Sum = 5: The subset is {2, 3}.
- Sum = 6: The subset is {1, 2, 3}.
Therefore, the minimum number of elements to be added is 1.
Input: arr[] = {1, 5, 10}, K = 20
Output: 2
Approach: The given problem can be solved by using the Greedy Approach which is based on the following observations:
- Consider X as the maximum number such that all the numbers in the range [1, X] can be formed by summing any subset of the array.
- Then it can be observed that by adding an integer Y to the array, the range modifies to [1, X+Y] as now every number in the range [X, X+Y] can be formed.
- Therefore, the idea is to greedily add the element which will increase the range most and will not skip any numbers in the new range obtained. It can be done by adding X every time to the array and modifying the X to 2*X.
Follow the steps below to solve the problem:
- Initialize two integer variables, say i and count as 0, to store the index of the array elements, and the count of elements needed respectively.
- Initialize a variable, say requiredNum as 1, to store the numbers up to which every number can be formed.
- Iterate until requiredNum ? K, and perform the following operations:
- If i < N and requiredNum >= arr[i] then increment requiredNum by arr[i] and i by 1.
- Otherwise, increment requiredNum by requiredNum, and count by 1.
- Finally, after completing the above steps, print the answer obtained in count.
Below is the implementation of the above approach:
C++
// C++ program for the above approach
#include <iostream>
using namespace std;
// Function to find the count of minimum
// elements to be inserted to form every
// number in a range
int minElements(int arr[], int N, int K)
{
// Stores the count of numbers needed
int count = 0;
// Stores the numbers upto which every
// numbers can be formed
long long requiredNum = 1;
// Stores the index of the array arr[]
int i = 0;
// Iterate until requiredSum is less than
// or equal to K
while (requiredNum <= K) {
// If i is less than N and requiredSum
// is greater than or equal to arr[i]
if (i < N && requiredNum >= arr[i]) {
// Increment requiredSum
// by arr[i]
requiredNum += arr[i];
// Increment i by 1
i++;
}
// Otherwise
else {
// Increment count by 1
count++;
// Increment requiredSum
// by requiredSum
requiredNum += requiredNum;
}
}
// Return result
return count;
}
// Driver Code
int main()
{
// Input
int arr[] = { 1, 3 };
int K = 6;
int N = sizeof(arr) / sizeof(arr[0]);
// Function Call
cout << minElements(arr, N, K) << endl;
return 0;
}
// Java program for the above approach
import java.io.*;
class GFG {
// Function to find the count of minimum
// elements to be inserted to form every
// number in a range
public static int minElements(int arr[], int N, int K)
{
// Stores the count of numbers needed
int count = 0;
// Stores the numbers upto which every
// numbers can be formed
long requiredNum = 1;
// Stores the index of the array arr[]
int i = 0;
// Iterate until requiredSum is less than
// or equal to K
while (requiredNum <= K) {
// If i is less than N and requiredSum
// is greater than or equal to arr[i]
if (i < N && requiredNum >= arr[i]) {
// Increment requiredSum
// by arr[i]
requiredNum += arr[i];
// Increment i by 1
i++;
}
// Otherwise
else {
// Increment count by 1
count++;
// Increment requiredSum
// by requiredSum
requiredNum += requiredNum;
}
}
// Return result
return count;
}
// Driver Code
public static void main(String[] args)
{
// Input
int arr[] = { 1, 3 };
int K = 6;
int N = arr.length;
// Function Call
System.out.println(minElements(arr, N, K));
// This code is contributed by Potta Lokesh
}
}
# Python 3 program for the above approach
# Function to find the count of minimum
# elements to be inserted to form every
# number in a range
def minElements(arr, N, K):
# Stores the count of numbers needed
count = 0
# Stores the numbers upto which every
# numbers can be formed
requiredNum = 1
# Stores the index of the array arr[]
i = 0
# Iterate until requiredSum is less than
# or equal to K
while (requiredNum <= K):
# If i is less than N and requiredSum
# is greater than or equal to arr[i]
if (i < N and requiredNum >= arr[i]):
# Increment requiredSum
# by arr[i]
requiredNum += arr[i]
# Increment i by 1
i += 1
# Otherwise
else:
# Increment count by 1
count += 1
# Increment requiredSum
# by requiredSum
requiredNum += requiredNum
# Return result
return count
# Driver Code
if __name__ == '__main__':
# Input
arr = [1, 3]
K = 6
N = len(arr)
# Function Call
print(minElements(arr, N, K))
# This code is contributed by SURENDRA_GANGWAR.
// C# program for the above approach
using System;
class GFG {
// Function to find the count of minimum
// elements to be inserted to form every
// number in a range
public static int minElements(int[] arr, int N, int K)
{
// Stores the count of numbers needed
int count = 0;
// Stores the numbers upto which every
// numbers can be formed
long requiredNum = 1;
// Stores the index of the array arr[]
int i = 0;
// Iterate until requiredSum is less than
// or equal to K
while (requiredNum <= K) {
// If i is less than N and requiredSum
// is greater than or equal to arr[i]
if (i < N && requiredNum >= arr[i]) {
// Increment requiredSum
// by arr[i]
requiredNum += arr[i];
// Increment i by 1
i++;
}
// Otherwise
else {
// Increment count by 1
count++;
// Increment requiredSum
// by requiredSum
requiredNum += requiredNum;
}
}
// Return result
return count;
}
// Driver Code
public static void Main(string[] args)
{
// Input
int[] arr = { 1, 3 };
int K = 6;
int N = arr.Length;
// Function Call
Console.Write(minElements(arr, N, K));
}
}
// This code is contributed by ukasp.
<script>
// Javascript program for the above approach
// Function to find the count of minimum
// elements to be inserted to form every
// number in a range
function minElements(arr, N, K) {
// Stores the count of numbers needed
let count = 0;
// Stores the numbers upto which every
// numbers can be formed
let requiredNum = 1;
// Stores the index of the array arr[]
let i = 0;
// Iterate until requiredSum is less than
// or equal to K
while (requiredNum <= K) {
// If i is less than N and requiredSum
// is greater than or equal to arr[i]
if (i < N && requiredNum >= arr[i]) {
// Increment requiredSum
// by arr[i]
requiredNum += arr[i];
// Increment i by 1
i++;
}
// Otherwise
else {
// Increment count by 1
count++;
// Increment requiredSum
// by requiredSum
requiredNum += requiredNum;
}
}
// Return result
return count;
}
// Driver Code
// Input
let arr = [1, 3];
let K = 6;
let N = arr.length;
// Function Call
document.write(minElements(arr, N, K) + "<br>");
// This code is contributed by _saurabh_jaiswal.
</script>
Time Complexity: O(N + log(K))
Auxiliary Space: O(1)
Similar Reads
Minimize sum of count of unique elements in Array after dividing into [1, N] subsets Given an array arr[] of length N, the task is to find the minimum number of unique elements possible in total when the array is divided into K subsets (for all K in the range [1, N]) i.e. sum of count of unique elements present in each subset after dividing the given array into K subsets. Examples:
7 min read
Minimize splits in given Array to find subsets of at most 2 elements with sum at most K Given an array arr[] of N integers and an integer K, the task is to calculate the minimum number of subsets of almost 2 elements the array can be divided such that the sum of elements in each subset is almost K. Examples: Input: arr[] = {1, 2, 3}, K = 3Output: 2Explanation: The given array can be di
6 min read
Count of ways to choose K elements from given Array with maximum sum Given an array, arr[] of size N and an integer K, the task is to find the number of ways of selecting K array elements, such that the sum of these K elements is the maximum possible sum. Examples: Input: arr[] = {3, 1, 1, 2}, K = 3 Output: 2Explanation: The possible ways of selecting 3 elements are:
8 min read
Distribute given arrays into K sets such that total sum of maximum and minimum elements of all sets is maximum Given two arrays, the first arr[] of size N and the second brr[] of size K. The task is to divide the first array arr[] into K sets such that the i-th set should contain brr[i] elements from the second array brr[], and the total sum of maximum and minimum elements of all sets is maximum. Examples: I
8 min read
Minimize cost for reducing array by replacing two elements with sum at most K times for any index Given an array arr[] of size N and an integer K. The task is to find the minimum cost required to collect the sum of the array. The sum of the array is collected by picking any element and adding it to an element of any index in the array. The addition of elements at the same index is allowed for at
11 min read