Algorithm to purchase items with limited money - c++

Question

I have X money to buy items that the price is Y[] (max 30 item) and a item can only be purchased once.
get the maximum money you can spend.
example
input:
money: 24
amount of item: 5
item price : 7, 7, 7, 5, 5
output: maximum money spend: 24 (7+7+5+5)
What is the best algorithm to achieve this?
I have tried to make the code, but it seems very not optimal
#include <iostream>
using namespace std;
int main()
{
int X;
cout << "money: ";
cin >> X;
int Y[30]; //max 30 items
int amount; //item amount
cout << "amount of items: ";
cin >> amount;
cout << "item price: ";
for(int i=1; i<=amount; i++)
{
cin >> Y[i];
}
//sort the price
bool sort = true;
while (sort == true)
{
int temp;
sort = false;
for(int x=amount; x>=2; x--)
{
if(Y[x] < Y[x-1])
{
temp = Y[x];
Y[x] = Y[x-1];
Y[x-1] = temp;
sort = true;
}
}
}
int priceTotal = 0;
int moneyLeft = X;
int maxMoneySpend = 0;
for(int j=0; j<=amount; j++)
{
priceTotal = 0;
moneyLeft = X;
for(int i=amount-j; i>=1; i--)
if(moneyLeft - Y[i] >= 0)
{
moneyLeft -= Y[i];
priceTotal += Y[i];
}
}
if (maxMoneySpend < priceTotal)
{
maxMoneySpend = priceTotal;
}
}
cout << "maximum money spend: " << maxMoneySpend << endl;
return 0;
}

Answer 1

This problem can be categorized as a classical 0/1 knapsack problem. You can use the following recursive implementation to do this task. Although this is having overlapping sub problem issues.
So, the best way to resolve it is using DP (Dynamic Programming).
typedef long long ll;
ll knapsack(ll id, ll a[], ll desiredVal) // array a[] contains the values ....
{
if(desiredVal<=0 || id<0)
return 0;
if(a[id]>desiredVal)
return knapsack(id-1,a,desiredVal);
else {
ll s1 = a[id] + knapsack(id-1,a,desiredVal-a[id]); // taken the weight //
ll s2 = knapsack(id-1,a,desiredVal); // Not taken the weight //
return max(s1,s2);
}
}
From main function you can call this method like the following :
knapsack(No_Item-1,a,desiredVal);
// Like in your exm : No_Item -> 5 , a[]={7,7,7,5,5}, desiredVal -> 24

Answer 2

As pointed out by others, this problem is NP-complete, thus there exists no efficient solution. Your solotion is even quite fast, but unfortunately incorrect.
You sum always from the cheap to the expensive elements. Let's say you have the elements (10, 4, 4, 2, 1), and an amount of 9. You will never end up taking 4, 4, 1, which fits perfectly. The reason is that you will only in the first loop take the 1. But without the 1, you cannot get an odd number (all the others are even). After you take the 1, you will add the 2, and the 4, having 7 together. The next 4 will not fit. When you take the 4 first, you can take the next 4, having 8. But will not get to 9.
Anyway, since Y is of cardinality up to 30, you will not find an algorithm for an optimal solution. 30 is too large for todays computers. The optimal solution would be to take all subsets of Y (which is called the power set of Y), calculate for each the cost, and take the most expensive of these. There are simply too many subsets for 30 items. It might work with 20 items. You cannot do much more efficient than this.