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

• Difficulty Level : Expert
• 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);`   `    ``// 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)

My Personal Notes arrow_drop_up
Recommended Articles
Page :