仅使用集合中的数字找到等于或大于给定目标的总和

Question

Example 1:

Shop selling beer, available packages are 6 and 10 units per package. Customer inputs 26 and algorithm replies 26, because 26 = 10 + 10 + 6.

Example 2:

Selling spices, available packages are 0.6, 1.5 and 3. Target value = 5. Algorithm returns value 5.1, because it is the nearest greater number than target possible to achieve with packages (3, 1.5, 0.6).

I need a Java method that will suggest that number.

Simmilar algorithm is described in Bin packing problem , but it doesn't suit me. I tried it and when it returned me the number smaller than target I was runnig it once again with increased target number. But it is not efficient when number of packages is huge.

I need almost the same algorithm, but with the equal or greater nearest number.

Similar question: Find if a number is a possible sum of two or more numbers in a given set - python .

Answer 1

First let's reduce this problem to integers rather than real numbers, otherwise we won't get a fast optimal algorithm out of this. For example, let's multiply all numbers by 100 and then just round it to the next integer. So say we have item sizes x ₁ , ..., x _n and target size Y . We want to minimize the value

k ₁ x ₁ + ... + k _n x _n - Y

under the conditions

(1) k _i is a non-positive integer for all n ≥ i ≥ 1

(2) k ₁ x ₁ + ... + k _n x _n - Y ≥ 0

One simple algorithm for this would be to ask a series of questions like

1. Can we achieve k ₁ x ₁ + ... + k _n x _n = Y + 0 ?
2. Can we achieve k ₁ x ₁ + ... + k _n x _n = Y + 1 ?
3. Can we achieve k ₁ x ₁ + ... + k _n x _n = Y + z ?
4. etc. with increasing z

until we get the answer "Yes". All of these problems are instances of the Knapsack problem with the weights set equal to the values of the items. The good news is that we can solve all those at once, if we can establish an upper bound for z . It's easy to show that there is a solution with z ≤ Y , unless all the x _i are larger than Y , in which case the solution is just to pick the smallest x _i .

So let's use the pseudopolynomial dynamic programming approach to solve Knapsack: Let f(i,j) be 1 iif we can reach total item size j with the first i items (x ₁ , ..., x _i ). We have the recurrence

f(0,0) = 1
f(0,j) = 0   for all j > 0
f(i,j) = f(i - 1, j) or f(i - 1, j - x_i) or f(i - 1, j - 2 * x_i) ...

We can solve this DP array in O(n * Y) time and O(Y) space. The result will be the first j ≥ Y with f(n, j) = 1 .

There are a few technical details that are left as an exercise to the reader:

• How to implement this in Java
• How to reconstruct the solution if needed. This can be done in O(n) time using the DP array (but then we need O(n * Y) space to remember the whole thing).

Answer 2

You want to solve the integer programming problem min(ct) st ct >= T, c >= 0 where T is your target weight, and c is a non-negative integer vector specifying how much of each package to purchase, and t is the vector specifying the weight of each package. You can either solve this with dynamic programming as pointed out by another answer, or, if your weights and target weight are too large then you can use general integer programming solvers, which have been highly optimized over the years to give good speed performance in practice.