快速的独特组合（来自有重复的列表），无需查找

Posted 2023-03-31

【中文标题】快速的独特组合（来自有重复的列表），无需查找

【英文标题】：FAST unique combinations (from list with duplicates) WITHOUT LOOKUPS

【发布时间】：2017-09-03 03:29:25

【问题描述】：

我似乎认为，尽管网上有很多算法和函数可以从唯一项目列表中生成任意大小的唯一组合，但在非唯一项目列表的情况下（即包含相同值重复的列表。）

问题是如何在生成器函数中生成 ON-THE-FLY all 非唯一列表中的唯一组合没有 过滤掉重复项的计算成本很高？

现在，由于对这个问题有一个赏金动机的答案，因此更容易更清楚地说明我期望实现的目标：

首先让我们提供代码说明如何检查组合 comboB 是否被认为与另一个组合 (comboA) 重复：

comboA = [1,2,2]
comboB = [2,1,2]
print("B is a duplicate of A:", comboA.sort()==comboB.sort())

在给定的示例中，B 是 A 的副本，并且 print() 打印 True。

在非唯一列表的情况下获得能够即时提供唯一组合的生成器函数的问题在这里解决：Getting unique combinations from a non-unique list of items, FASTER?，但提供的生成器函数需要查找并需要内存，这会导致问题以防万一的大量组合。

在当前版本的答案提供函数中，无需任何查找即可完成这项工作，并且在这里似乎是正确的答案，但是...

摆脱查找的目的是在列表重复的情况下加快生成唯一组合的速度。

我最初（编写此问题的第一个版本）错误地认为不需要创建用于确保唯一性的查找集的代码有望比需要查找的代码具有优势。 事实并非如此。至少并非总是如此。到目前为止提供的答案中的代码不使用查找，但在没有冗余列表或列表中只有几个冗余项目的情况下生成所有组合需要更多时间。

这里有一些时间来说明当前的情况：

-----------------
 k: 6 len(ls): 48
Combos   Used Code                               Time
---------------------------------------------------------
12271512 len(list(combinations(ls,k)))       :  2.036 seconds
12271512 len(list(subbags(ls,k)))            : 50.540 seconds
12271512 len(list(uniqueCombinations(ls,k))) :  8.174 seconds
12271512 len(set(combinations(sorted(ls),k))):  7.233 seconds
---------------------------------------------------------
12271512 len(list(combinations(ls,k)))       :  2.030 seconds
       1 len(list(subbags(ls,k)))            :  0.001 seconds
       1 len(list(uniqueCombinations(ls,k))) :  3.619 seconds
       1 len(set(combinations(sorted(ls),k))):  2.592 seconds

以上时间说明了两个极端：没有重复，只有重复。所有其他时间都在这两者之间。

我对上述结果的解释是纯 Python 函数（没有 itertools 或其他 C 编译模块）可以非常快，但也可以慢得多，具体取决于列表中有多少重复项。因此，可能无法为提供所需功能的 Python .so 扩展模块编写 C++ 代码。

【问题讨论】：

如何确定 (1,2,2) 和 (2,1,2) 中的哪一个是“正确的”？

你的第一条评论就是我要找的。​​span>

@Claudio 我还发现了this thread，其中包含更更简单的iterative algorithm（需要对输入进行排序）和recursive algorithm的代码。它们似乎比当前的答案更有效率，但我还没有真正测试过它们。

@lazydog 请参阅此处cython.org 和此处***.com/questions/43729052/…，如果您希望使用现成的模块比当前最佳答案更快，请随时提供另一个答案。您的答案中的递归算法已经提供了一个非常好的 C 编译 Python 模块，它仅比使用带有循环而不是递归的算法的迭代器类版本的 Cython 优化代码慢一点。抱歉 - 还没有时间将问题更新为有关此主题的最新技术。

【参考方案1】：

您可以预处理输入列表，而不是对输出进行后处理/过滤。这样，您可以避免一开始就产生重复。预处理涉及对输入进行排序（或使用collections.Counter）。一种可能的递归实现是：

def subbags(bag, k):
    a = sorted(bag)
    n = len(a)
    sub = []

    def index_of_next_unique_item(i):
        j = i + 1

        while j < n and a[j] == a[i]:
            j += 1

        return j

    def combinate(i):
        if len(sub) == k:
            yield tuple(sub)
        elif n - i >= k - len(sub):
            sub.append(a[i])
            yield from combinate(i + 1)
            sub.pop()
            yield from combinate(index_of_next_unique_item(i))

    yield from combinate(0)

bag = [1, 2, 3, 1, 2, 1]
k = 3
i = -1

print(sorted(bag), k)
print('---')

for i, subbag in enumerate(subbags(bag, k)):
    print(subbag)

print('---')
print(i + 1)

输出：

[1, 1, 1, 2, 2, 3] 3
---
(1, 1, 1)
(1, 1, 2)
(1, 1, 3)
(1, 2, 2)
(1, 2, 3)
(2, 2, 3)
---
6

递归需要一些堆栈空间，但是这+对输入进行排序应该比生成和丢弃重复使用更少的时间+内存。

【讨论】：

不幸的是，我对 Python/C api 并不熟悉，而且直到周日晚上我才有很多空闲时间。稍后我会尝试研究它，并尝试开发一种迭代算法，除非其他人想击败我。

@Claudio 所以看起来我没有合适的环境来构建 C 扩展模块，并且设置它（在 Windows 上）似乎相当复杂。如果我不能逐步运行和测试它，我就不能编写 C（或 C++）扩展。对不起。我还写了一个iterative Python 算法，它类似于documentation 中给出的itertools.combinations_with_replacement 的Python 等效算法，但它非常丑陋，充其量也没有比递归代码快得多。

@Claudio：在您删除的评论中，您要求懒狗为您编写一个 C/C++ 模块。这是不可接受的，请不要再这样做了。

【参考方案2】：

目前最先进的技术最初是由 50 次而不是 100 次代表的赏金启发而来的（而不是完全用 C 编写的 Python 扩展模块）：

一种高效的算法和实现，在最佳（和平均）情况下优于显而易见的 (set + combinations) 方法，在最坏情况下与之竞争。

似乎可以使用一种“先造假”的方法来满足这一要求。当前的最新技术是有两种生成器函数算法可用于解决在非唯一列表的情况下获得唯一组合的问题。下面提供的算法将它们结合起来成为可能，因为它似乎存在列表中唯一项目百分比的阈值，可用于在两种算法之间进行适当切换。唯一性百分比的计算是用非常少的计算时间完成的，由于所用时间的常见变化，它甚至没有清楚地显示在最终结果中。

def iterFastUniqueCombos(lstList, comboSize, percUniqueThresh=60):

    lstListSorted = sorted(lstList)
    lenListSorted = len(lstListSorted)

    percUnique = 100.0 - 100.0*(lenListSorted-len(set(lstListSorted)))/lenListSorted

    lstComboCandidate = []
    setUniqueCombos = set()

    def idxNextUnique(idxItemOfList):
        idxNextUniqueCandidate = idxItemOfList + 1
        while (
                idxNextUniqueCandidate < lenListSorted 
                    and 
                lstListSorted[idxNextUniqueCandidate] == lstListSorted[idxItemOfList]
        ): # while
            idxNextUniqueCandidate += 1
        idxNextUnique = idxNextUniqueCandidate
        return idxNextUnique

    def combinate(idxItemOfList):
        if len(lstComboCandidate) == sizeOfCombo:
            yield tuple(lstComboCandidate)
        elif lenListSorted - idxItemOfList >= sizeOfCombo - len(lstComboCandidate):
            lstComboCandidate.append(lstListSorted[idxItemOfList])
            yield from combinate(idxItemOfList + 1)
            lstComboCandidate.pop()
            yield from combinate(idxNextUnique(idxItemOfList))

    if percUnique > percUniqueThresh:
        from itertools import combinations
        allCombos = combinations(lstListSorted, comboSize)
        for comboCandidate in allCombos:
            if comboCandidate in setUniqueCombos:
                continue
            yield comboCandidate
            setUniqueCombos.add(comboCandidate)
    else:
        yield from combinate(0)
    #:if/else    
#:def iterFastUniqueCombos()

下面提供的时序表明上面的iterFastUniqueCombos()生成器函数提供了明显的优势 超过uniqueCombinations() 变体，以防列表中的唯一元素少于 60% 并且不差于 on (set + combinations) 基于 uniqueCombinations() 生成器函数在相反的情况下，它比 iterUniqueCombos() 快得多（由于在 (set + combinations) 和 (no lookups) 变体在列表中唯一元素数量的 60% 阈值）：

===========  sizeOfCombo: 6   sizeOfList: 48   noOfUniqueInList 1   percUnique   2
Combos: 12271512  print(len(list(combinations(lst,k))))           :   2.04968 seconds.
Combos:        1  print(len(list(      iterUniqueCombos(lst,k)))) :   0.00011 seconds.
Combos:        1  print(len(list(  iterFastUniqueCombos(lst,k)))) :   0.00008 seconds.
Combos:        1  print(len(list(    uniqueCombinations(lst,k)))) :   3.61812 seconds.

==========  sizeOfCombo: 6   sizeOfList: 48   noOfUniqueInList 48   percUnique 100
Combos: 12271512  print(len(list(combinations(lst,k))))           :   1.99383 seconds.
Combos: 12271512  print(len(list(      iterUniqueCombos(lst,k)))) :  49.72461 seconds.
Combos: 12271512  print(len(list(  iterFastUniqueCombos(lst,k)))) :   8.07997 seconds.
Combos: 12271512  print(len(list(    uniqueCombinations(lst,k)))) :   8.11974 seconds.

==========  sizeOfCombo: 6   sizeOfList: 48   noOfUniqueInList 27   percUnique  56
Combos: 12271512  print(len(list(combinations(lst,k))))           :   2.02774 seconds.
Combos:   534704  print(len(list(      iterUniqueCombos(lst,k)))) :   1.60052 seconds.
Combos:   534704  print(len(list(  iterFastUniqueCombos(lst,k)))) :   1.62002 seconds.
Combos:   534704  print(len(list(    uniqueCombinations(lst,k)))) :   3.41156 seconds.

==========  sizeOfCombo: 6   sizeOfList: 48   noOfUniqueInList 31   percUnique  64
Combos: 12271512  print(len(list(combinations(lst,k))))           :   2.03539 seconds.
Combos:  1114062  print(len(list(      iterUniqueCombos(lst,k)))) :   3.49330 seconds.
Combos:  1114062  print(len(list(  iterFastUniqueCombos(lst,k)))) :   3.64474 seconds.
Combos:  1114062  print(len(list(    uniqueCombinations(lst,k)))) :   3.61857 seconds.

【讨论】：

我不确定如何将递归算法重写为等效的迭代版本，但here 是一种替代迭代算法，可能更容易适应 C 扩展。 itertools.combinations_with_replacement 的 source code 可能会有所帮助。不过，我认为您的答案中的组合元算法方法更简单有效。它类似于标准的快速排序+插入排序组合。