0-1 背包：在空间优化实施中寻找解决方案集

Question

I want to solve a 0-1 Knapsack problem with a maximum weight of ~ 200k and over 100k elements and eventual determination of the item set rather than only the optimal weight.

Researching 0-1 Knapsack, I read that a common way to solve this problem is via dynamic programming and creating a table containing optimal solutions for subproblems, thus splitting up the original problem into smaller parts and later backtracing on the table to determine the item set. The maximum profit, without regard for the items taken, can be calculated in a memory efficient manner (as outlined here ).

The obvious issue here is that for the dimensions I have in mind, this approach would consume more memory than is feasible (requiring O(n*W) space, with n being the number of elements and W being the maximum capacity). Researching further I found mention ( here for example, also see "Knapsack Problems" by Kellerer, Pferschy and Pisinger) of a memory efficient way to solve 0-1 Knapsack.

We start by splitting up the item set up into two subsets, roughly equal in size. We treat both subsets as their own knapsack problem given the original maximum weight W and determine the last row of the maximum profit calculation for both subsets in the memory-efficient way (detailed above).

The next step is to find out where to optimally split the two subsets. To do this, we determine the maximum profit for weight w1 and w2 of the two rows. As I understand, it is critical to maintain w1 + w2 = W , so I iterate through the first row and take the index on the opposite end of the current index. My current implementation for this step looks like this:

def split(weights, values, n, w, i):
    # s1 is the bigger subset size if n is not even
    s1 = n // 2 + (n&1)
    s2 = n // 2

    row1 = maximum_profit(weights, values, s1, w)
    row2 = maximum_profit(weights[s1:], values[s1:], s2, w)

    max_profits_for_capacity = [x + y for x, y in zip(row1, row2[::-1])]
    max_profits = max(max_profits_for_capacity)                           
    optimal_weight_index = max_profits_for_capacity.index(max_value)

    c1 = row1[optimal_weight_index]
    c2 = row2[w-optimal_weight_index-1]

c1 and c2 are the maximum profits for each of the subsets then while maintaining c1 + c2 = W . With these values we recurse into each of the subsets:

split(weights[:s1], values[:s1], s1, c1, i)      
split(weights[s1:], values[s1:], s2, c2, i+s1)

This is where the descriptions lose me. Eventually this code will recurse to n == 1 with a value of w . How do I determine if an element is included given an item index i and a maximum (local) capacity w ?

I can provide a small example data set to illustrate the workings of my code in detail and where it goes wrong. Thank you very much.

Answer 1

First, I guess you have a mistake saying about c , w and their relation as capacity, but getting c1 and c2 from profit lists.

To the question, by the returning value of your split function you can define what type of question you are answering.

As you take the split direct to n == 1 point and you want to get the indices of the picked items into knapsack, you can simply at this step return the value consisting of [0] or [1] as the output:

if n == 1:
  if weights[0] < w:
    return [1]
  return [0]

• [1] means picking the item into resulting set
• [0] otherwise

then concatenate them into one during other steps of recurse of your split function like:

def split(..):
  ..
  # since it is lists concatenation
  return split(weights[:s1], values[:s1], s1, c1, i) + split(weights[s1:], values[s1:], s2, c2, i+s1)

In result you will get list of size n (for the number of items you make splits) with zeroes and ones.

Total complexity would be:

• O(nWlogn) for time, since we make splits till the n == 1 step
• O(W) for memory, since we store always only a part of the resulting list when recurse