平衡大小相等的阵列

Question

我不知道正确的名字是“balance”。

我有一个由 2n 个正整数元素组成的数组，我想分成两个 n 个元素数组，它们的平均值之间的差异最小。例如：

values: {4, 4, 7, 8, 10, 15}
(some magic here)
a: {7, 8, 10}
b: {4, 4, 15}

我不确定是否总是将最小的数字与最大的数字相结合是否会始终分割差异较小的平均值。有没有办法实现这个算法总是正确分裂？

Answer 1

如果我正确理解您的需求，一种快速且大致正确的解决方案是：

1. 对原始数组进行排序
2. 将新数组分配为每个数组的大小为原始数组的一半。如果原始长度为奇数，则决定哪个新数组获取额外元素。
3. 从左到右（或从右到左）遍历原始数组。将奇数索引元素放入其中一个新数组中，将偶数索引元素放入另一个新数组中。

关键是对原始数组进行排序，如果您的要求允许就地排序，或者如果不允许就地排序，则创建一个新的“原始”数组，它是真实原始数组的排序副本。

如果 N 相当大并且数字的分布相当均匀（例如，没有大的偏向一端或另一端），此解决方案将非常接近理想解决方案。

如果你真的要求平均值尽可能接近，即使数字有很大的偏差，我能想到的唯一方法是尝试每一种排列并保持差异最小的那个平均。

Answer 2

local function some_magic(V)
   assert(#V % 2 == 0 and #V > 0)
   table.sort(V)
   local S = {[-1] = math.huge, [0] = 0}
   for i = 1, #V do
      S[i] = S[i-1] + V[i]
   end
   local half_sum = math.floor(S[#V] / 2)
   local half_len = #V / 2
   local m = 2^math.ceil(math.log(half_len+1)/math.log(2))
   local P = {[0] = 0}
   for idx = #V, 1, -1 do
      local v, P2 = V[idx], {}
      for k in pairs(P) do
         if math.floor(k/m) + v + S[half_len - k%m - 1] <= half_sum then
            P2[k + v*m + 1] = idx
         end
      end
      for k, v in pairs(P2) do
         P[k] = P[k] or v
      end
   end
   local k = 0
   for next_k in pairs(P) do
      if next_k > k and next_k%m == half_len then
         k = next_k
      end
   end
   local A, B, prev_idx = {}, {}, 0
   repeat
      local idx = P[k]
      for i = prev_idx + 1, idx - 1 do
         table.insert(B, V[i])
      end
      table.insert(A, V[idx])
      prev_idx = idx
      k = k - V[idx]*m - 1
   until k == 0
   for i = prev_idx + 1, #V do
      table.insert(B, V[i])
   end
   return A, B
end

local values = {4, 4, 7, 8, 10, 15}
print('values: '..table.concat(values, ','))
local a, b = some_magic(values)
print('a: '..table.concat(a, ','))
print('b: '..table.concat(b, ','))

------------- Output: ------------
values: 4,4,7,8,10,15
a: 4,4,15
b: 7,8,10