Question

我有一个N个正数的列表，按升序排序，L [0]到L [N-1]。

我想迭代M个不同列表元素的子集（没有替换，顺序不重要），1＆lt; = M <= N，根据它们的部分和进行排序。 M不固定，最终结果应考虑所有可能的子集。

我只想要有效的K个最小子集（理想情况下是K中的多项式）。枚举M <= K的所有子集的明显算法是O（K！）。

我可以通过在最小堆中放置K迭代器（1＆lt; = M＆lt; = K）并让主迭代器在堆根上运行来将问题减少到固定大小为M的子集。

基本上我需要Python函数调用：

sorted(itertools.combinations(L, M), key=sum)[:K]

...但有效率（N~200，K~30）应该在不到1秒的时间内运行。

示例：

L = [1, 2, 5, 10, 11]
K = 8
answer = [(1,), (2,), (1,2), (5,), (1,5), (2,5), (1,2,5), (10,)]

答案：

正如David的回答所示，重要的技巧是，对于要输出的子集S，必须先前输出S的所有子集，特别是仅去除了1个元素的子集。因此，每次输出子集时，都可以添加此子集的所有1元素扩展（最多K），并且仍然可以确保下一个输出的子集将位于所有考虑的子集的列表中。点。

完全有效，高效的Python功能：

def sorted_subsets(L, K):
  candidates = [(L[i], (i,)) for i in xrange(min(len(L), K))]

  for j in xrange(K):
    new = candidates.pop(0)
    yield tuple(L[i] for i in new[1])
    new_candidates = [(L[i] + new[0], (i,) + new[1]) for i in xrange(new[1][0])]
    candidates = sorted(candidates + new_candidates)[:K-j-1]

UPDATE，找到O（K log K）算法。

这类似于上面的技巧，但是不是添加所有添加的元素大于子集的最大值的1元素扩展，而是仅考虑2个扩展：一个添加max（S）+1，并且另一个将max（S）转换为max（S）+ 1（最终会生成右边的所有1元素扩展）。

import heapq

def sorted_subsets_faster(L, K):
  candidates = [(L[0], (0,))]

  for j in xrange(K):
    new = heapq.heappop(candidates)
    yield tuple(L[i] for i in new[1])
    i = new[1][-1]
    if i+1 < len(L):
      heapq.heappush(candidates, (new[0] + L[i+1], new[1] + (i+1,)))
      heapq.heappush(candidates, (new[0] - L[i] + L[i+1], new[1][:-1] + (i+1,)))

从我的基准测试来看，K的所有值都更快。

此外，没有必要事先提供K的值，我们可以随时迭代和停止，而不会改变算法的效率。另请注意，候选人数量以K + 1为界。

通过使用优先级 deque （最小 - 最大堆）而不是优先级队列，可能会进一步改进，但坦率地说，我对此解决方案感到满意。我会对线性算法感兴趣，或者证明它是不可能的。

Answer 1

这是一些粗略的Python-ish伪代码：

final = []
L = L[:K]    # Anything after the first K is too big already
sorted_candidates = L[] 
while len( final ) < K:
    final.append( sorted_candidates[0] )  # We keep it sorted so the first option
                                          # is always the smallest sum not
                                          # already included
    # If you just added a subset of size A, make a bunch of subsets of size A+1
    expansion = [sorted_candidates[0].add( x ) 
                   for x in L and x not already included in sorted_candidates[0]]

    # We're done with the first element, so remove it
    sorted_candidates = sorted_candidates[1:]

    # Now go through and build a new set of sorted candidates by getting the
    # smallest possible ones from sorted_candidates and expansion
    new_candidates = []
    for i in range(K - len( final )):
        if sum( expansion[0] ) < sum( sorted_candidates[0] ):
            new_candidates.append( expansion[0] )
            expansion = expansion[1:]
        else:
            new_candidates.append( sorted_candidates[0] )
            sorted_candidates = sorted_candidates[1:]
    sorted_candidates = new_candidates

我们假设你会做一些事情，比如以有效的方式删除数组的第一个元素，因此循环中唯一真正的工作是构建扩展和重建sorted_candidates。这两个步骤都少于K步，所以作为一个上限，你看的是一个O（K）的循环，运行K次，所以算法为O（K ^ 2）。

对有序的部分和进行有效迭代

1 个答案: