How to find minimum cost and combination that satisfies (or over) the goal?

Question

I have an algorithm problem created by myself, and I am seeking some guidance here. The goal is to get at least X gold. There are different dealers selling different amounts of golds at different prices. I need to find an optimal combination that minimizes the cost while buying at least X gold.

Rules:

• You must buy the gold in full amounts
• You can buy any number of the same item

This resembles an unbounded knapsack problem, but in this problem there are no limit to the amount of gold to buy. Solving this using knapsack will give me solutions that are below the required amount of the goal, which are obviously wrong answers. Obviously I could brute-force it by gradually increasing the limit of the knapsack, but that would not be optimal in terms of performance.

As mentioned, I am seeking for some guidance here, on some less known algorithms that would solve this problem. I am not asking for code.

---

In an example, these are the prices available.

Item ID	Gold	Price
1	120	0.99
2	600	4.99
3	1,960	14.99
4	3,960	29.99
5	4,970	38.89
6	6,560	49.99
7	12,960	99.99
8	14,000	104.99

For this example, my task is to buy at least 12,880 gold. I need to find the combination and how many of each item I need to buy to satisfy the goal, which is get at least 12,880 gold while minimizing the cost.

---

My attempt to solve is the process of finding the algorithm to solve it. Here is a sheet with the different combinations I have tested, but I still cannot find a viable algorithm to find the optimal combination.

In the image, you can see that buying 2 item_4 and 1 item_5 is currently my best solution. But it is not for certain the optimal solution.

---

Edit 1:

Add some more details/rules above

Edit 2:

I am just asking for some guidance here and not any code from you guys. I have solved similar problems with unbounded knapsack, but the solution cannot be applied here at all. This is because I need at least the amount, and not less than or equal to the amount. These are two different problems and I don't see any reason to post an unrelated code regarding the knapsack that does not even works as an attempt to solve the problem.

Edit 3:

I realized that I need to scope this question a bit, to make it reasonable. So here are the constraints.

n: Amount of gold in the goal
k: Number of dealers/items
m: Maximum amount of gold that will be sold as a single purchase

n <= 1000000
k <= 1000
m <= 10000000

I am again not looking for any code from you, just some advice for possible solutions, and I will write my own code.

Answer 1

To solve the problem, we need to extend the generic unbounded knapsack algorithm for minimizing cost with additional steps. Here I present a generic solution for all unbounded knapsack problems with at least W weight while minimizing total cost.

Preconditions:

• It is assumed that non-integer numbers have a limited number of decimal places. To work with integers, these numbers are multiplied by a factor. For example, 49.99 becomes 4999.
• The terms "gold" and "price" are used interchangeably with "weight" and "cost," respectively, to align with the knapsack algorithm terminology.
• Let W represents the required weight.
• Let N be the number of items.

Solution:

1. Apply the general algorithm for solving the unbounded knapsack problem (minimizing cost) to construct a dp table. The dp table contains minimized costs and maximized weights for all capacities up to the required weight W. Additionally, maintain an array to store the combination of items for later retrieval.
2. Assuming the dp table is sorted in ascending order based on capacity, follow these steps:
   • Initialize min_cost as infinity.
   • Iterate over each item in the items list and calculate the difference W - item_weight. For each iteration, search the dp table to find the first maximized weight that is equal to or greater than the calculated value. Use binary search for this.
   • As a result, the sum of found_weight and item_weight represents a total weight of at least W.
   • Use the index of the found weight in the dp_costs array to calculate the total cost.
   • If the total cost is less than the current min_cost, update both min_cost with the new value.
   • After completing the item loop, use the found_weight and item weights to find the combination of needed to achieve the min_cost.

Complexity:

Time: O(N * (W + log(W)))

First Knapsack with O(N * W), then binary search within a loop O(N log(W))

Space: O(W)

We are using 1D lists for the "dp table".

Final Code:

# Items with weights and costs
items = [
    (120, 99),
    (600, 499),
    (1960, 1499),
    (3960, 2999),
    (4960, 3889),
    (6560, 4999),
    (12960, 9999),
    (14000, 10499),
]

def find_index_of_first_occurrence_or_higher(lst, value):
    ''' Binary search on a sorted list and returns the index of the first occurrence of a value or the next higher value if the value is not found.'''
    lo, hi = 0, len(lst) - 1
    while lo <= hi:
        mid = lo + (hi - lo) // 2
        if lst[mid] < value:
            lo = mid + 1
        else:
            hi = mid - 1
    return hi + 1

def unbounded_knapsack_minimize_cost_required_capacity(items, capacity):
    dp_costs = [float('inf')] * (capacity + 1)      # Accumulated costs
    dp_wts = [0] * (capacity + 1)                   # Accumulated weights
    dp_items = [0] * (capacity + 1)                 # Item IDs in sequence
    dp_costs[0] = 0
    
    # Iterate over each capacity from 1 to the maximum capacity
    for i in range(1, capacity + 1):
        for j, (wt, cost) in enumerate(items):
            # Check if the weight of the current item is less than or equal to the current capacity
            if wt <= i:
                dp_wt = dp_wts[i - wt] + wt
                # If adding the item gives more weight than previously
                if dp_wt >= dp_wts[i]:
                    dp_cost = dp_costs[i - wt] + cost
                    # If the accumulated cost is less than previously
                    if dp_cost < dp_costs[i]:
                        dp_costs[i] = dp_cost
                        dp_wts[i] = dp_wt
                        dp_items[i] = j
        if dp_wts[i] == 0:
            # Use previous best as current best
            dp_costs[i] = dp_costs[i-1]
            dp_wts[i] = dp_wts[i-1]
            dp_items[i] = dp_items[i-1]
    
    # There could be items that gives more weight but less total cost. To handle these cases, loop through all the items once
    # Make use of the already created dp (i.e dp_costs) table, remove equivalent amount or less from the accumulated weight. Then apply the item weight and check if the cost is less.
    min_cost = float('inf')
    for i, (wt, cost) in enumerate(items):
        weight_to_find = max(capacity - wt, 0)
        
        found_weight = find_index_of_first_occurrence_or_higher(dp_wts, weight_to_find)
        dp_cost = dp_costs[found_weight] + cost
        
        if dp_cost < min_cost:
            min_cost = dp_cost
            min_cost_last_item = i
            total_weight = found_weight
    
    # Find the total combination that gives the min_cost
    min_combination = [min_cost_last_item]
    while total_weight > 0:
        item = dp_items[total_weight]
        min_combination.append(item)
        # Find previous item by subtracting weights
        item_weight = items[item][0]
        total_weight -= item_weight
    return min_cost, min_combination

capacity = int(input("Input capacity of the knapsack: "))
min_cost, min_combination = unbounded_knapsack_minimize_cost_required_capacity(items, capacity)

print("Minimum cost:", min_cost/100)
print("Minimum combination:", min_combination)
print("Final weight:", sum(map(lambda x: items[x][0], min_combination)))

Answer 2

tl;dr;

In general (when you have issue like this) steps are:

1. First you model mathematics/logic of your problem , define set domain, variable types and their relationship or limits.
2. Then you analyze your math in form of change (derivatives/integrals) and try to find independent actors ( by following operation order PEMDAS.
3. Then you separate each independent actor into smaller tasks that you can test, execute and verify MRE.
4. Then you join it all together into cohesive algorithm that implements your solution.

---

I think you require additional info, to solve an set of equations containing 2 unknowns (ie amount of gold and price) you tend to need either one formula that connect the two or two independent formulas for each.

Since you have 2 variables (unknowns), you can approach this in 4 ways that might branch out later on:

1. Forget about one of those variables (GOLD, or PRICE) and just find algorithm that handles one of them - prioritize your data.
2. Find new variable that ties them together in some sort of function or formula which limits your applicability - and test it by finding differential/derivative or integral of relationship described by new variable.
3. Use them both but independently and then revalue results with some sort of weighted AI trough iteration in order to find some sort of rule or law.
4. Find a larger problem (which those 2 variables are part of) and find algorithm for that. - superset for GOLD and PRICE

---

The way I see it, it seems that you have a floating number limit issue here, since there are infinite amount of Rational Numbers within 0 and 1 in any progressive set ( where amount of GOLD or PRICE increases over time) you will always have some issues matching the GOAL in any random progressive set. So you can approach it by limiting it to specific interval that you may search in and finding direction of "movement" with logic of:

For set A (a in A: a > 0, a in Q+) and set B (b in B: b > 0, b in Q+) we have a variable c (c in C, a_i <= c <= b_i | b_i <= c <= a_i, c in Q+), direction of mapping (either A or B) is defined by m(a,b,c)=(2C/(a+b))-1 where if m is lesser than 0 it is closer to smaller of a,b. However issue in logic is the domain of the set, since Q is defined by p/q of 2 integers for every real number (float, double) you have issues with range (or step) of linear mapping function.

For any value C (in this case QUANTITY of gold) and sets of A and B (GOAL and FUNDS) you can have potentially infinite amount of values c that are small enough to be disregarded if minimizing the cost is secondary goal. So without any "reference" in amount of gold compared to GOAL (that is derivative of time) you might have issues of never reaching a goal by a wide margin - programmatically.

So you need additional information (or function analysis) in order to find a bordering limit at which buying gold for X price is justified. I would approach this problem from Rational number perspective and represent each price as integer division of closest value, then if DIFFERENCE between GOAL and FUNDS have same GCD as price then I would "buy" it (if GCD isn't 1 and is naturally decreasing as FUNDS are closer to GOAL). Of course in this approach primary numbers are a pain in the butt, and you might still have wide margin to reach your goal but it should be less than removing chunks out of funds.

---

Second possible approach is from economic standpoint where you need additional variable of "Required Price" or some sort of estimation of wealth of whomever is buying. But that can change your desire for this algo quite a bit, since you will not have diversity in your portfolio and would (sort of) limit your domain to specific range. If in same case as before:

For set A (a in A: a > 0, a in Q+) and set B (b in B: b > 0, b in Q+) we have a variable c (c in C, a_i <= c <= b_i | b_i <= c <= a_i, c in Q+) then price becomes c/a, c/b and which if c is p/q, a is w/e and b is v/u then we have typical Rational division (which is multiplication of its inverse):

c/a = (p/q)/(w/e)=(pe/wq) | c/b = (p/q)/(v/u) = (pu/qv) -> c/a=c*a^-1, c/b=c*b^-1

Then for some Required Price (RP) and some acceptable "leeway"[lw] we can write it as -lw <= some (a^-1, b^-1) <= lw if RP is also p/q. So if you have Minimum amount of Gold and Capital, RQ = Minimum amount of Gold / Capital ( or Ratio in your second image). This approach will ignore any price that is outside of "leeway" and will tend to have margin as wide as inverse of lw.

---

This is why you need another variable in data set that has 2 elements (GOLD,PRICE) if you are searching for solution for only one variable (GOLD). You can ignore PRICE and focus on GOLD to GOLD mapping, or you can add some additional variables (such as PRICE, FUNDS, CAPITAL...) that are either combination of two or describe their relationship.

Each step of algorithm is reduction in information, since we can't handle infinity outside of abstractions. You can think about it, and you can model it but once you try to apply it probability rises alot. So here you can either sit down and go trough each and every probability in mapping and try and find some relationship (or theory) or you can simplify it by introducing another variable or relationship.

Hope this helps.