N个非重叠最优分区

Question

Here is a problem I run into a few days ago. Given a list of integer items, we want to partition the items into at most N nonoverlapping, consecutive bins, in a way that minimizes the maximum number of items in any bin. For example, suppose we are given the items (5, 2, 3, 6, 1, 6), and we want 3 bins. We can optimally partition these as follows:

• n < 3 : 1, 2 (2 items)
• 3 <= n < 6 : 3, 5 (2 items)
• 6 <= n : 6, 6 (2 items)

Every bin has 2 items, so we can't do any better than that. Can anyone share your idea about this question?

Answer 1

Given n bins and an array with p items, here is one greedy algorithm you could use.

To minimize the max number of items in a bin:

• p <= n Try to use p bins.

  Simply try and put each item in it's own bin. If you have duplicate numbers then your average will be unavoidably worse.

• p > n Greedily use all bins but try to keep each one's member count near floor(p / n) .

  1. Group duplicate numbers
  2. Pad the largest duplicate bins that fall short of floor(p / n) with unique numbers to the left and right (if they exist).

  3. Count the number of bins you have and determine the number mergers you need to make, let's call it r .

     Repeat the following r times:

     • Check each possible neighbouring bin pairing; find and perform the minimum merger

Example

• {1,5,6,9,8,8,6,2,5,4,7,5,2,4,5,3,2,8,7,5} 20 items to 4 bins
• {1}{2, 2, 2}{3}{4, 4}{5, 5, 5, 5, 5}{6, 6}{7, 7}{8, 8, 8}{9} 1. sorted and grouped
• {1, 2, 2, 2, 3}{4, 4}{5, 5, 5, 5, 5}{6, 6}{7, 7}{8, 8, 8, 9} 2. greedy capture by largest groups
• {1, 2, 2, 2, 3}{4, 4}{5, 5, 5, 5, 5}{6, 6}{7, 7}{8, 8, 8, 9} 3. 6 bins but we want 4, so 2 mergers need to be made.
  • {1, 2, 2, 2, 3}{4, 4}{5, 5, 5, 5, 5}{6, 6, 7, 7}{8, 8, 8, 9} 3. first merger
  • {1, 2, 2, 2, 3, 4, 4}{5, 5, 5, 5, 5}{6, 6, 7, 7}{8, 8, 8, 9} 3. second merger

So the minimum achievable max was 7.

Answer 2

Here is some psudocode that will give you just one solution with the minimum bin quantity possible:

Sort the list of "Elements" with Element as a pair {Value, Quanity}.

So for example {5,2,3,6,1,6} becomes an ordered set:
Let S = {{1,1},{2,1},{3,1},{5,1},{6,2}}

Let A = the largest quanity of any particular value in the set
Let X = Items in List
Let N = Number of bins
Let MinNum = ceiling ( X / N )
if A > MinNum then Let MinNum = A

Create an array BIN(1 to N+1) of pointers to linked lists of elements.

For I from 1 to N
  Remove as many elements from the front of S that are less than MinNum
  and Add them to Bin(I)
Next I
Let Bin(I+1)=any remaining in S

LOOP while Bin(I+1) not empty
  Let MinNum = MinNum + 1
  For I from 1 to N
    Remove as many elements from the front of Bin(I+1) so that Bin(I) is less than MinNum
    and Add them to Bin(I)
  Next I
END LOOP

Your minimum bin size possible will be MinNum and BIN(1) to Bin(N) will contain the distribution of values.