# Minimum count of elements to be inserted in Array to form all values in [1, K] using subset sum

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 = 6Output:1Explanation:

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 = 20Output: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**.

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

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

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

**Output**

1

**Time Complexity:** O(N + log(K))**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**.