给定一部电梯，其最大重量和n个人的重量为x_i，请找出所需的最小乘车次数

Question

input:
max_weight = 550
n = 4
x_i = [120, 175, 250, 150]

output:
2  
// [[250, 175, 120], [150]]

My initial impression is that this looks very similar to a dynamic programming coin change/knapsack problem, however it is not coin change (which would be asking for the fewest number of weights to make an exact amount), and it is not knapsack (the weights do not have values and it's like I can have more than 1 knapsack).

Is there a common name/solution for this problem?

Answer 1

This is actually a (1D) Bin Packing problem :

In the bin packing problem, objects of different volumes must be packed into a finite number of bins or containers each of volume V in a way that minimizes the number of bins used . In computational complexity theory, it is a combinatorial NP-hard problem.

Here the persons map on the objects en the bins on the rides. Like the bin packing problem we want to minimize the number of rides "used" and each person occupies a certain "volume" (that person's weight).

The bin packing problem is - as said in the article - NP-hard. We can use dynamic programming (but it still has - worst case - exponential time).

The paper A New Algorithm for Optimal Bin Packing by Richard E. Korf discusses an algorithm to solve this problem exactly. It works by using a heuristic approach first and calculating a lower bound, and then use branch and bound to iteratively derive a better solution than the heuristic one until the lower bound is reached, or no solution can be found anymore.

Answer 2

如果我错了（不是最有效的），请纠正我，但是我认为您可以将所有权重放入max堆中 ，然后使用贪心算法来选择集合。

Answer 3

You're on the right track. The problem is solved by a modified coin-change algorithm: rather than demanding an exact solution, you find the one that attains the highest total without exceeding the target amount. Of course, if you find a solution whose shortfall is less than any remaining set element, you stop and report that solution.

When you find a solution, remove the "used" weights and iterate until you have allocated them all. The number of iterations is the quantity of elevators you need.

If you sort the elements in descending order, this gives you a "greedy" beginning with backtracking. I suspect that this is reasonably close to optimal for many cases, especially if you memoize the results so that you don't repeat mistakes on the next iteration.

You might try some pathological cases, such as a limit of 100, and extreme weights like

[93, 91, ..., 5, 4, 4]

The "greedy" algorithm goes for 93+5 first, but later settles for 91+4+4 (closer solution). This is where the memoization comes in handy.

Does that move you toward a solution?