我陷入了竞争性的编程挑战：
https://www.hackerrank.com/challenges/fair-cut/problem
我尝试过的方法：使用数组的中间值对数组进行排序，并使用2个指针进行左遍历，使用其他进行右遍历并检查最小化差异（这不是DP方法btw）。在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表示设置补充。
答案 0 :(得分：0)
这个想法怎么样？考虑从大到小排序的A。让f(i, j)表示一个元组：（1）可以通过对整数集合进行某种除法而得到的不公平度的最小度量，直到索引为i Li得到j sum(I) }整数，（2）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，如下例所示。在这种情况下，我想知道每个人是否可以为下一个(min, sum (I))提供不同的解决方案。无论如何，我们至少可以将搜索空间缩小到最小值。我们还可以观察并避免在同一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))
：
i