Skip to content
Related Articles

Related Articles

Improve Article

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




My Personal Notes arrow_drop_up
Recommended Articles
Page :