You have N coins with positive integer values. What is the smallest sum you cannot create using a subset of the coins?
Examples:
Input: N = 5, coins[] = {2, 9, 1, 2, 7}
Output: 6
Explanation:
- Sum = 1, we can take the coin with value 1.
- Sum = 2, we can take the coin with value 2.
- Sum = 3, we can take coins with value 1 and 2.
- Sum = 4, we can take coins with value 2 and 2.
- Sum = 5, we can take coins with value 1, 2 and 2.
- Sum = 6, no possible subset of coins can sum up to 6.
Input: N = 3, coins[] = {1, 2, 3}
Output: 7
Explanation:
- Sum = 1, we can take the coin with value 1.
- Sum = 2, we can take the coin with value 2.
- Sum = 3, we can take coins with value 3.
- Sum = 4, we can take coins with value 1 and 3.
- Sum = 5, we can take coins with value 2 and 3.
- Sum = 6, we can take coins with value 1, 2 and 3.
- Sum = 7, no possible subset of coins can sum up to 7.
Approach: To solve the problem, follow the below idea:
The problem can be solved by using Greedy approach. We can start from the smallest value coin and move to higher values. The main idea is to start from the coins of smallest value and build up the sum of coins we can form. Let’s say we have some coins whose total value is X, so the maximum value of the next coin can be X + 1. If the next coin has a value greater than X + 1 then (X + 1) is the smallest sum which we cannot create using any subset of coins. Otherwise, if the value of the next coin is less than (X + 1) we can add it to the total value to get the new total sum X.
Step-by-step algorithm:
- Sort the array of coins in increasing order of values.
- Maintain a variable X which stores the maximum value of the next coin.
- Iterate from 0 to N – 1, and check if arr[i] > X or not.
- If arr[i] > X, return X as the answer.
- Else if arr[i] <= X, update X = X + arr[i].
- After all the iterations if we haven’t returned yet, return (X + 1) as the answer.
#include <bits/stdc++.h> #define ll long long using namespace std;
// Function to find the maximum sum which we cannot // construct using given coins ll solve(ll* arr, ll N) { // Variable to store the maximum value of the next coin
ll X = 1LL;
// Sort the coins in ascending order of their values
sort(arr, arr + N);
for ( int i = 0; i < N; i++) {
// If the current coin's value is greater than X,
// then X is the answer
if (arr[i] > X) {
return X;
}
// If current coin's value is less than or equal to
// X, then we can update X as X + arr[i]
X += arr[i];
}
return X;
} int main()
{ // Sample Input
ll N = 5;
ll arr[] = { 2, 9, 1, 2, 7 };
cout << solve(arr, N);
} |
import java.util.Arrays;
public class MaximumSumNotConstructible {
// Function to find the maximum sum which we cannot
// construct using given coins
static long solve( long [] arr, int N) {
// Variable to store the maximum value of the next coin
long X = 1 ;
// Sort the coins in ascending order of their values
Arrays.sort(arr);
for ( int i = 0 ; i < N; i++) {
// If the current coin's value is greater than X,
// then X is the answer
if (arr[i] > X) {
return X;
}
// If current coin's value is less than or equal to
// X, then we can update X as X + arr[i]
X += arr[i];
}
return X;
}
public static void main(String[] args) {
// Sample Input
int N = 5 ;
long [] arr = { 2 , 9 , 1 , 2 , 7 };
System.out.println(solve(arr, N));
}
} // This code is contributed by rambabuguphka |
# Function to find the maximum sum which we cannot # construct using given coins def solve(arr, N):
# Variable to store the maximum value of the next coin
X = 1
# Sort the coins in ascending order of their values
arr.sort()
for coin in arr:
# If the current coin's value is greater than X,
# then X is the answer
if coin > X:
return X
# If current coin's value is less than or equal to
# X, then we can update X as X + coin
X + = coin
return X
if __name__ = = "__main__" :
# Sample Input
N = 5
arr = [ 2 , 9 , 1 , 2 , 7 ]
print (solve(arr, N))
|
using System;
class Program
{ // Function to find the maximum sum which we cannot
// construct using given coins
static long Solve( long [] arr, long N)
{
// Variable to store the maximum value of the next coin
long X = 1;
// Sort the coins in ascending order of their values
Array.Sort(arr);
for ( int i = 0; i < N; i++)
{
// If the current coin's value is greater than X,
// then X is the answer
if (arr[i] > X)
{
return X;
}
// If the current coin's value is less than or equal to
// X, then we can update X as X + arr[i]
X += arr[i];
}
return X;
}
static void Main()
{
// Sample Input
long N = 5;
long [] arr = { 2, 9, 1, 2, 7 };
Console.WriteLine(Solve(arr, N));
}
} |
// Function to find the maximum sum which we cannot // construct using given coins function solve(arr) {
// Variable to store the maximum value of the next coin
let X = 1;
// Sort the coins in ascending order of their values
arr.sort((a, b) => a - b);
for (let i = 0; i < arr.length; i++) {
// If the current coin's value is greater than X,
// then X is the answer
if (arr[i] > X) {
return X;
}
// If current coin's value is less than or equal to
// X, then we can update X as X + arr[i]
X += arr[i];
}
return X;
} // Sample Input let arr = [2, 9, 1, 2, 7]; console.log(solve(arr)); // This code is contributed by Ayush Mishra |
6
Time Complexity: O(N), where N is the number of coins.
Auxiliary Space: O(1)