如何应对 Hackerrank 的 Fair Cut 挑战？

Question

我被困在一个竞争激烈的编程挑战中：

https://www.hackerrank.com/challenges/fair-cut/problem

我尝试了什么：对数组进行排序，取数组的中值，并使用 2 个指针，一个用于左遍历，另一个用于右遍历，并检查是否最小化差异（顺便说一句，这不是 DP 方法）。这种方法适用于 21 个测试用例中的大约 10 个。

我一直在努力为这个问题建模动态规划表。那么如何为这个问题写一个逻辑递推关系呢？任何有关该问题的见解或提示将不胜感激。

问题陈述：

Li 和 Lu 有 n 整数，a_1, a_2, ..., a_n，他们想在他们两人之间公平分配。他们决定，如果 Li 得到索引为 I = {i_1, i_2, ..., i_k} 的整数（这意味着 Lu 得到索引为 J = {1, ..., n} \ I 的整数），那么这种划分的不公平性度量为：

f(I) = sum |a_i - a_j| for i <- I, j <- J

找出可以通过对整数集进行一些除法获得的最小不公平度量，其中 Li 恰好得到 k 整数。

注意A \ B 表示集合补码。

Answer 1

这个想法怎么样？考虑A 从大到小排序。让f(i, j) 表示一个元组：（1）通过对直到索引i 的整数集进行一些除法可以获得的最小不公平度量，其中Li 恰好得到j 整数，（2）@987654326 @。那么：

f(i, j) = min(
  f(i-1, j),

  let r = f(m, j-1)
      // Subtract the difference of Ai from larger a's in I
   in r[0] - (r[1] - |I| * Ai) +
      // Subtract Ai from larger a's in J if applicable
      prefixSum(i-1) - r[1] - (i - 1 - |I|) * Ai +
      // Subtract smaller a's in J from Ai if applicable
      (|J| - (i - 1 - |I|) - 1) * Ai - (sum(J) - (prefixSum(i-1) - r[1]) - Ai)
)
for all (j-1) <= m < i

复杂度可能是O(n * k = n^2)。我唯一感到困惑的是，当最小值重复时，我们可以有多个sum(I)，如下例所示。在这种情况下，我想知道是否每个人都可以为下一个k 产生不同的解决方案。无论如何，我们至少可以将搜索空间缩小到最小。我们还可以观察并避免在相同的i 迭代中重新计算相同的(min, sum (I)) 元组。

让我们将第一个示例中的数字从大到小排序：

k = 2
4 3 1 2

=> 4 3 2 1

初始化f(i, 1):

                                                  (min, sum(I))
a_i: 4 =>  4 * 3 - sum(1,2,3)       = 12 - 6    = (6,   4     )

a_i: 3 =>  4 - 3 + 2 * 3 - sum(1,2) = 1 + 6 - 3 = (4,   3     )
a_i: 2 =>  sum(4,3) - 2 * 2 + 2 - 1 = 7 - 4 + 1 = (4,   2 or 3)
a_i: 1 =>  sum(4,3,2) - 3 * 1       = 9 - 3     = (4,   2 or 3)

迭代f(i, 2):

a_i: 4 =>  Infinity

a_i: 3 =>  min(
             Infinity,

             6 - (4 - 1 * 3) +
             4 - 4 - (1 - 1) * 3 +
             (3 - 1) * 3 - (6 - (4 - 4) - 3)

           ) = (8, 3 + 4 = 7) // (min, sum(I))

a_i: 2 =>  min(
             8,

             6 - (4 - 1 * 2) +
             7 - 4 - (2 - 1) * 2 +
             (3 - (2 - 1) - 1) * 2 - (6 - (7 - 4) - 2)
             = (6, 2 + 4 = 6), // (min, sum(I))

             4 - (3 - 1 * 2) + 
             7 - 3 - (2 - 1) * 2 +
             (3 - (2 - 1) - 1) * 2 - (7 - (7 - 3) - 2)
             = (6, 2 + 3 = 5) // (min, sum(I))

           ) = (6, 5 or 6) // (min, sum(I))

a_i: 1 =>  min(
             (6, 5 or 6),

             6 - (4 - 1 * 1) +
             9 - 4 - (3 - 1) * 1 +
             (3 - (3 - 1) - 1) * 1 - (6 - (9 - 4) - 1)
             = (6, 4 + 1 = 5),  // (min, sum(I))

             4 - (3 - 1 * 1) + 
             9 - 3 - (3 - 1) * 1 +
             (3 - (3 - 1) - 1) * 1 - (7 - (9 - 3) - 1)
             = (6, 3 + 1 = 4),  // (min, sum(I))

             4 - (2 - 1 * 1) + 
             9 - 2 - (3 - 1) * 1 +
             N / A
             = (8, 1 + 2 = 3)  // (min, sum(I))

           ) = (6, 4 5 or 6)  // (min, sum(I))