# 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:

1. Sum = 1: The subset is {1}.
2. Sum = 2: The subset is {2}.
3. Sum = 3: The subset is {3}.
4. Sum = 4: The subset is {1, 3}.
5. Sum = 5: The subset is {2, 3}.
6. 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:

1. 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.
2. 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.
3. 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 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

 // 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     } }

## Python3

 # 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#

 // 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.

## Javascript



Output

1

Time Complexity: O(N + log(K))
Auxiliary Space: O(1)

Previous
Next