具有固定子集大小的 Sum-subset

Question

sum-subset problem 声明：

给定一组整数，是否存在总和为零的非空子集？

这个问题通常是 NP 完全的。我很好奇这种轻微变体的复杂性是否已知：

给定一组整数，是否存在大小为k 且总和为零的子集？

例如，如果k = 1，您可以进行二分搜索以在O(log n) 中找到答案。如果是k = 2，那么您可以将其降为O(n log n)（例如，参见Find a pair of elements from an array whose sum equals a given number）。如果是k = 3，那么你可以做O(n^2)（例如见Finding three elements in an array whose sum is closest to a given number）。

是否存在可以作为k 函数的已知界限？

作为动机，我正在考虑这个问题How do you partition an array into 2 parts such that the two parts have equal average? 并试图确定它是否实际上是 NP 完全的。答案就在于有没有上面所说的公式。

除非有一个通用的解决方案，否则我很想知道k=4 的最佳界限。

Answer 1

对于k=4，空间复杂度O(n)，时间复杂度O(n² * log(n))

对数组进行排序。从 2 个最小和 2 个最大元素开始，按非递减顺序计算所有 lesser 2 个元素的总和 (a[i] + a[j])，并按非递增顺序计算所有 greater 2 个元素的总和 (a[k] + a[l])。如果总和小于零，则增加lesser sum，如果总和大于零，则减少greater 1，当总和为零（成功）或a[i] + a[j] > a[k] + a[l]（失败）时停止。

诀窍是遍历所有索引i 和j，使(a[i] + a[j]) 永远不会减少。对于k 和l，(a[k] + a[l]) 永远不会增加。优先级队列有助于做到这一点：

1. 将key=(a[i] + a[j]), value=(i = 0, j = 1) 放入优先队列。
2. 从优先队列中弹出(sum, i, j)。
3. 在上述算法中使用sum。
4. 仅当(a[i+1] + a[j]), i+1, j 和(a[i] + a[j+1]), i, j+1 尚未使用这些元素时，才将这些元素放入优先队列。要跟踪使用过的元素，请为每个“i”维护一个最大使用过的“j”数组。仅使用大于“i”的“j”值就足够了。
5. 从第 2 步继续。

对于 k>4

如果空间复杂度限制为 O(n)，我找不到比对 k-4 值使用蛮力和对剩余 4 值使用上述算法更好的方法。时间复杂度 O(n^(k-2) * log(n)).

对于非常大的k integer linear programming 可能会有一些改进。

更新

如果n 非常大（与最大整数值的顺序相同），则可以实现 O(1) 优先级队列，将复杂度提高到 O(n²) 和 O (n^(k-2)).

如果n >= k * INT_MAX，则可以使用具有 O(n) 空间复杂度的不同算法。为所有可能的k/2 值之和预先计算一个位集。并用它来检查其他k/2 值的总和。时间复杂度为 O(n^(ceil(k/2)))。

Answer 2

判断W+X+Y+Z={w+x+y+z|中是否为0的问题w in W, x in X, y in Y, z in Z} 基本相同，除了没有烦人的退化情况（即问题可以用最少的资源相互简化）。

这个问题（以及 k = 4 的原始问题）有一个 O(n^2 log n)-时间，O(n)-空间算法。 k = 2 的 O(n log n) 时间算法（确定 A + B 中是否为 0）以排序顺序访问 A，以反向排序顺序访问 B。因此，我们只需要一个 A = W + X 的 O(n) 空间迭代器，它可以对称地重复用于 B = Y + Z。让 W = {w1, ..., wn} 按排序顺序。对于 X 中的所有 x，将键值项 (w1 + x, (1, x)) 插入优先级队列。反复删除最小元素(wi + x, (i, x))并插入(wi+1 + x, (i+1, x))。

Answer 3

O(n^2log(n))中k=4的解

第 1 步：计算两两和并对列表进行排序。有 n(n-1)/2 个和。所以复杂度是O(n^2log(n))。保留总和的个人的身份。

第 2 步：为上述列表中的每个元素搜索补集，并确保它们不共享“个体”。有 n^2 次搜索，每个搜索的复杂度为 O(log(n))

编辑：原始算法的空间复杂度为 O(n^2)。通过模拟一个虚拟二维矩阵，空间复杂度可以降低到 O(1)（O(n)，如果你考虑空间来存储数组的排序版本）。

首先关于二维矩阵：对数字进行排序并使用成对求和创建矩阵 X。现在矩阵是这样一种方式，即所有的行和列都被排序。要在此矩阵中搜索一个值，请搜索对角线上的数字。如果数字在 X[i,i] 和 X[i+1,i+1] 之间，则基本上可以将搜索空间减半为矩阵 X[i:N, 0:i] 和 X[0:i ， 在]。结果搜索算法为 O(log^2n)（我不太确定。有人可以检查吗？）。

现在，不要使用实矩阵，而是使用虚拟矩阵，其中 X[i,j] 是根据需要计算的，而不是预先计算它们。

结果时间复杂度：O( (nlogn)^2 )。

PS：在下面的链接中，它说 2D 排序矩阵搜索的复杂度是 O(n) 复杂度。如果这是真的（即 O(log^2n) 不正确），那么最终的复杂度是 O(n^3)。

Answer 4

以 awesomo 的回答为基础......如果我们可以假设数字是排序的，对于给定的 k，我们可以做得比 O(n^k) 更好；只需取所有 O(n^(k-1)) 个大小为 (k-1) 的子集，然后对剩余的数字进行二分搜索，当添加到第一个 (k-1) 时，给出目标。这是 O(n^(k-1) log n)。这意味着复杂性肯定比这要低。

实际上，如果我们知道 k=3 的复杂度为 O(n^2)，我们可以对 k > 3 做得更好：选择所有 (k-3)-子集，其中有 O( n^(k-3))，然后在剩余元素上解决 O(n^2) 中的问题。对于 k >= 3，这是 O(n^(k-1))。

但是，也许你可以做得更好？我会考虑这个的。

编辑：我最初打算添加很多建议对这个问题提出不同的看法，但我决定发布一个删节版。我鼓励其他发帖者看看他们是否认为这个想法有任何价值。分析很困难，但它可能已经足够疯狂了。

我们可以利用我们有一个固定的 k 以及奇数和偶数之和以特定方式表现这一事实来定义一个递归算法来解决这个问题。

首先，修改问题，使列表中同时包含偶数和奇数（如果全部为偶数，则可以通过除以 2 来完成，或者如果全部为奇数，则从目标总和中减去 1 和 k ，并根据需要重复）。

接下来，利用仅使用偶数个奇数才能达到偶数目标总和的事实，并且仅使用奇数个奇数才能达到奇数目标总和。生成适当的奇数子集，并使用偶数递归调用算法，总和减去被检查的奇数子集的总和，k 减去奇数子集的大小。当 k = 1 时，进行二分查找。如果曾经 k > n（不确定这是否会发生），则返回 false。

如果您的奇数很少，这可以让您非常快速地选择必须是获胜子集的一部分的术语，或者丢弃不能的术语。您可以使用减法技巧将具有大量偶数的问题转换为具有大量奇数的等效问题。因此，最坏的情况一定是偶数和奇数的数量非常相似......这就是我现在所处的位置。一个无用的宽松上限比蛮力差很多数量级，但我觉得这可能至少与蛮力一样好。欢迎提出想法！

EDIT2：以上示例，用于说明。

{1, 2, 2, 6, 7, 7, 20}, k = 3, sum = 20.
Subset {}:
 {2, 2, 6, 20}, k = 3, sum = 20
 = {1, 1, 3, 10}, k = 3, sum = 10
 Subset {}:
  {10}, k = 3, sum = 10
  Failure
 Subset {1, 1}:
  {10}, k = 1, sum = 8
  Failure
 Subset {1, 3}:
  {10}, k = 1, sum = 6
  Failure
Subset {1, 7}:
 {2, 2, 6, 20}, k = 1, sum = 12
 Failure
Subset {7, 7}:
 {2, 2, 6, 20}, k = 1, sum = 6
 Success

Answer 5

非常相似的问题：

Is this variant of the subset sum problem easier to solve?

它仍然是 NP 完全的。

如果不是，则子集和也将在 P 中，因为它可以表示为 F(1) | F(2) | ... F(n) 其中 F 是您的函数。这将有 O(O(F(1)) + O(F(2)) + O(F(n))) 仍然是多项式，这是不正确的，因为我们知道它是 NP 完全的。

请注意，如果您对输入有一定的限制，则可以实现多项式时间。

另请注意，蛮力运行时可以使用二项式系数计算。

Answer 6

时间复杂度是微不足道的O(n^k)（n 元素中k 大小的子集的数量）。

由于k 是一个给定的常数，一个（可能相当高阶的）多项式上限将复杂度作为n 的函数。