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
Minimum value that can't be formed using OR of elements of the Array Given an array of positive integers arr[]. The task is to Find the minimum positive value which cannot be formed using OR operator on any subset of the array. Examples: Input: arr[] = {2, 3}Output: 1Explanation: Since 1 is missing from array and we cannot make it using OR for any other subset of thi
6 min read
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
Minimum Subarray flips required to convert all elements of a Binary Array to K The problem statement is asking for the minimum number of operations required to convert all the elements of a given binary array arr[] to a specified value K, where K can be either 0 or 1. The operations can be performed on any index X of the array, and the operation is to flip all the elements of
8 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
Find minimum value of the expression by choosing K elements from given array Given an array of integers arr of size N, the task is to find the minimum possible of the expression by choosing exactly K(? N) integers form given array arr. Let say if chosen elements are stored in array B (B1, B2, B3.....Bk) then value of expression: x = \sum_{i=1}^k\sum_{j=1}^k(B_i - B_j)^{2} Ex
10 min read
Minimum value to add to arr[i] so that an array can be split at index i with equal sum Given an array arr[] of integers, the task is to find the minimum non-negative integer k such that there exists an index j in the given array such that when arr[j] is updated as arr[j] + k, the sum of elements of an array from index arr[0] to arr[j] is equal to the sum of elements from arr[j + 1] to
13 min read
Find the minimum value of K required to remove all elements from the array in at most M operations Given array A[] of size N and integer M, Perform the following operation until the array becomes empty. Choose K and the pick first K elements of array A[]. In one operation subtract all these chosen K elements by 1 if any element becomes zero that element will be deleted and it will be replaced by
13 min read
Minimum count of indices to be skipped for every index of Array to keep sum till that index at most T Given an array, arr[] of size N and an integer T. The task is to find for each index the minimum number of indices that should be skipped if the sum till the ith index should not exceed T. Examples: Input: N = 7, T = 15, arr[] = {1, 2, 3, 4, 5, 6, 7}Output: 0 0 0 0 0 2 3 Explanation: No indices need
8 min read
Minimum cost to convert all elements of a K-size subarray to 0 from given Ternary Array with subarray sum as cost Given an array arr[] of N integers, where each array element is either 0, 1, or 2, and an integer K, the task is to print the minimum cost needed to convert all the elements of the array to 0s by selecting a subarray of size K and converting any array element of the subarray to 0 in one operation wi
11 min read