找到所需的最小元素数，以使它们的总和等于或超过 S

Question

我知道这可以通过对数组进行排序并取较大的数字直到满足所需条件来完成。这至少需要 nlog(n) 排序时间。

对nlog(n) 有什么改进吗？

我们可以假设所有数字都是正数。

Answer 1

这是O(n + size(smallest subset) * log(n)) 的算法。如果最小子集远小于数组，则为O(n)。

如果我对算法的描述不清楚，请阅读http://en.wikipedia.org/wiki/Heap_%28data_structure%29（虽然细节不多，但细节都在那里）。

1. 将数组转换为堆，以便最大元素及时可用O(n)。
2. 反复从堆中提取最大的元素，直到它们的总和足够大。这需要O(size(smallest subset) * log(n))。

这几乎肯定是他们所希望的答案，尽管没有得到它不应该是破坏交易。

编辑：这是另一种变体，通常更快，但可能更慢。

Walk through elements, until the sum of the first few exceeds S.  Store current_sum.
Copy those elements into an array.
Heapify that array such that the minimum is easy to find, remember the minimum.
For each remaining element in the main array:
    if min(in our heap) < element:
        insert element into heap
        increase current_sum by element
        while S + min(in our heap) < current_sum:
            current_sum -= min(in our heap)
            remove min from heap

如果我们在不操作堆的情况下拒绝大部分数组，这可能比之前的解决方案快两倍。但也有可能变慢，比如当数组中的最后一个元素恰好大于 S 时。

Answer 2

假设数字是整数，您可以改进通常的n lg(n) 排序复杂性，因为在这种情况下，我们有额外的信息，即值介于 0 和 S 之间（出于我们的目的，大于 S 的整数是相同的作为 S）。

由于值的范围是有限的，您可以使用非比较排序算法，例如Pigeonhole Sort 或Radix Sort 低于n lg(n)。

请注意，这些方法依赖于 S 的某些函数，因此如果 S 变得足够大（并且 n 保持足够小），您最好恢复为比较排序。

Answer 3

这是该问题的 O(n) 预期时间解决方案。这有点像 Moron 的想法，但我们不会放弃选择算法在每个步骤中所做的工作，而是从可能位于中间的项目开始尝试，而不是使用重复加倍的方法。

或者，它实际上只是quickselect，并为剩余的金额额外记账。

首先，很明显，如果您的元素按排序顺序排列，您可以先选择最大的项目，直到超过所需的总和。我们的解决方案就是这样，除了我们会尽量不去发现排序信息，因为排序很慢。

您希望能够确定给定值是否是截止值。如果我们包含该值和大于它的所有内容，我们会达到或超过 S，但是当我们删除它时，我们会低于 S，那么我们就是金色的。

这是伪代码，我没有针对边缘情况对其进行测试，但这可以理解。

def Solve(arr, s):
  # We could get rid of worse case O(n^2) behavior that basically never happens 
  # by selecting the median here deterministically, but in practice, the constant
  # factor on the algorithm will be much worse.
  p = random_element(arr)
  left_arr, right_arr = partition(arr, p)
  # assume p is in neither left_arr nor right_arr
  right_sum = sum(right_arr)
  if right_sum + p >= s:
    if right_sum < s:
      # solved it, p forms the cut off
      return len(right_arr) + 1    
    # took too much, at least we eliminated left_arr and p
    return Solve(right_arr, s) 
  else:
    # didn't take enough yet, include all elements from and eliminate right_arr and p
    return len(right_arr) + 1 + Solve(left_arr, s - right_sum - p)  

Answer 4

您可以对 Theta(nlogn) 做的一个改进（渐近）是获得 O(n log K) 时间算法，其中 K 是所需的最小元素数。

因此，如果 K 是常数，或者说 log n，这比排序更好（渐近地）。当然，如果 K 是 n^epsilon，那么这并不比 Theta(n logn) 好。

这样做的方法是使用selection algorithms，它可以告诉你O(n)时间内第i^th个最大的元素。

现在对 K 进行二分搜索，从 i=1（最大）开始，每回合将 i 加倍等。

你找到第i^th个最大的，然后找到第i个最大元素的和并检查它是否大于S。

这样，您将运行 O(log K) 次选择算法（即 O(n)），总运行时间为 O(n log K)。

Answer 5

1. 消除数字
2. 鸽子洞排序数字

将元素按排序顺序从高到低求和，直到超过 S。