在计算之前删除包含某些值的组合

Question

给定一个列表和排除元素，是否可以忽略包含这些元素的组合计算？

示例 1

给定l = [1, 2, 3, 4, 5]，我想在计算之前计算size 4 的所有组合，并排除包含(1, 3) 的组合。

结果是：

    All results:            Wanted results:

    [1, 2, 3, 4]            [1, 2, 4, 5]
    [1, 2, 3, 5]            [2, 3, 4, 5]
    [1, 2, 4, 5]
    [1, 3, 4, 5]
    [2, 3, 4, 5]

所有包含 1 和 3 的组合均已删除。

示例 2

@Eric Duminil 建议

l = [1, 2, 3, 4, 5, 6]、size 4 和

的结果

• 不包括第二列中的(1, 2, 3)

• 不包括第三列中的(1, 2)

  All results:        Wanted results 1            Wanted results 2
                      (Excluding [1, 2, 3]):      (Excluding [1, 2])
  
  [1, 2, 3, 4]        [1, 2, 4, 5]                [1, 3, 4, 5]
  [1, 2, 3, 5]        [1, 2, 4, 6]                [1, 3, 4, 6]
  [1, 2, 3, 6]        [1, 2, 5, 6]                [1, 3, 5, 6]
  [1, 2, 4, 5]        [1, 3, 4, 5]                [1, 4, 5, 6]
  [1, 2, 4, 6]        [1, 3, 4, 6]                [2, 3, 4, 5]
  [1, 2, 5, 6]        [1, 3, 5, 6]                [2, 3, 4, 6]
  [1, 3, 4, 5]        [1, 4, 5, 6]                [2, 3, 5, 6]
  [1, 3, 4, 6]        [2, 3, 4, 5]                [2, 4, 5, 6]
  [1, 3, 5, 6]        [2, 3, 4, 6]                [3, 4, 5, 6]
  [1, 4, 5, 6]        [2, 3, 5, 6]                                
  [2, 3, 4, 5]        [2, 4, 5, 6]                                
  [2, 3, 4, 6]        [3, 4, 5, 6]                                
  [2, 3, 5, 6]           
  [2, 4, 5, 6]           
  [3, 4, 5, 6]        
  

所有包含 1 和 2 和 3 的组合都已从想要的结果 1 中删除

所有包含 1 和 2 的组合都已从想要的结果 2 中删除

我有更大的组合要计算，但这需要很多时间，我想使用这些排除项来减少这个时间。

尝试过的解决方案

使用方法1，仍然计算组合

使用方法2，我尝试修改combinations function，但在计算之前我找不到合适的方法来忽略我的排除列表。

            Method 1                    |               Method 2
                                        |               
def main():                             |   def combinations(iterable, r):
    l = list(range(1, 6))               |       pool = tuple(iterable)
    comb = combinations(l, 4)           |       n = len(pool)
                                        |       if r > n:
    for i in comb:                      |           return
        if set([1, 3]).issubset(i):     |       indices = list(range(r))
            continue                    |       yield tuple(pool[i] for i in indices)
        else                            |       while True:
            process()                   |           for i in reversed(range(r)):
                                        |               if indices[i] != i + n - r:
                                        |                   break
                                        |               else:
                                        |                   return
                                        |           indices[i] += 1
                                        |           for j in range(i+1, r):
                                        |               indices[j] = indices[j-1] + 1
                                        |           yield tuple(pool[i] for i in indices)

编辑：

首先，谢谢大家的帮助，我忘了提供更多关于约束的细节。

• 输出的顺序不相关，例如，如果结果是[1, 2, 4, 5] [2, 3, 4, 5] 或[2, 3, 4, 5] [1, 2, 4, 5]，则不重要。

• 组合的元素应该（如果可能的话）排序，[1, 2, 4, 5] [2, 3, 4, 5] 而不是[2, 1, 5, 4] [3, 2, 4, 5]，但这并不重要，因为组合可以在之后排序。

• 排除列表是不应出现组合一起的所有项目的列表。例如，如果我的排除列表是 (1, 2, 3)，则不应计算包含 1 和 2 和 3 的所有组合。但是，允许使用 1 和 2 而不是 3 的组合。在这种情况下，如果我排除包含 (1, 2) 和 (1, 2, 3) 的组合，那将完全没有用，因为将由 (1, 2, 3) 过滤的所有组合都已由 (1, 2) 过滤

• 多个排除列表必须是可能的，因为我对我的组合使用了多个约束。

测试答案

@tobias_k 此解决方案将排除列表 (1, 2, 3) 视为 OR 排除含义，如果我理解良好，将排除 (1, 2), (2, 3) and (1, 3)，这在一个案例中很有用，但不适用于我当前的问题，我修改了问题以提供更多详细信息，抱歉造成混淆。在您的回答中，我不能仅使用列表 (1, 2) 和 (1, 3) 作为您指定的排除项。然而，这种解决方案的一大优势是允许多重排除。

@Kasramvd 和 @mikuszefski 您的解决方案非常接近我想要的，如果它确实包含多个排除列表，那就是答案。

谢谢

Answer 1

（事实证明这并不完全符合 OP 的要求。仍然将其留在这里，因为它可能对其他人有所帮助。）

---

要包含互斥元素，您可以将它们包装在列表中的列表中，获取其中的combinations，然后获取子列表组合的product：

>>> from itertools import combinations, product
>>> l = [[1, 3], [2], [4], [5]]
>>> [c for c in combinations(l, 4)]
[([1, 3], [2], [4], [5])]
>>> [p for c in combinations(l, 4) for p in product(*c)]
[(1, 2, 4, 5), (3, 2, 4, 5)]

一个更复杂的例子：

>>> l = [[1, 3], [2, 4, 5], [6], [7]]
>>> [c for c in combinations(l, 3)]
[([1, 3], [2, 4, 5], [6]),
 ([1, 3], [2, 4, 5], [7]),
 ([1, 3], [6], [7]),
 ([2, 4, 5], [6], [7])]
>>> [p for c in combinations(l, 3) for p in product(*c)]
[(1, 2, 6),
 (1, 4, 6),
 ... 13 more ...
 (4, 6, 7),
 (5, 6, 7)]

这不会生成任何以后要过滤掉的“垃圾”组合。但是，它假定您最多需要每个“独占”组中的一个元素，例如在第二个示例中，它不仅阻止与2,4,5 的组合，而且还阻止与2,4、4,5 或2,5 的组合。此外，不可能（或至少不容易）只拥有1,3 和1,5 之一，但允许3,5。 （也许可以将其扩展到这些情况，但我还不确定是否以及如何。）

---

您可以将其包装在一个函数中，从您的（假定的）格式派生出稍微不同的输入格式并返回一个一致的生成器表达式。这里，lst 是元素列表，r 是每个组合的项目数，exclude_groups 是互斥元素组的列表：

from itertools import combinations, product

def comb_with_excludes(lst, r, exclude_groups):
    ex_set = {e for es in exclude_groups for e in es}
    tmp = exclude_groups + [[x] for x in lst if x not in ex_set]
    return (p for c in combinations(tmp, r) for p in product(*c))

lst = [1, 2, 3, 4, 5, 6, 7]
excludes = [[1, 3], [2, 4, 5]]
for x in comb_with_excludes(lst, 3, excludes):
    print(x)

Answer 2

（事实证明，我的previous answer 并没有真正满足问题的限制，这是另一个问题。我将其作为单独的答案发布，因为方法大不相同，原始答案可能仍然有帮助其他人。）

您可以递归地实现这一点，每次在递归之前将另一个元素添加到组合中，检查这是否会违反其中一个排除集。这不会生成无效的组合，它适用于重叠的排除集（如(1,3), (1,5)），以及具有两个以上元素的排除集（如(2,4,5)，允许除所有元素之外的任何组合）。

def comb_with_excludes(lst, n, excludes, i=0, taken=()):
    if n == 0:
        yield taken  # no more needed
    elif i <= len(lst) - n:
        t2 = taken + (lst[i],)  # add current element
        if not any(e.issubset(t2) for e in excludes):
            yield from comb_with_excludes(lst, n-1, excludes, i+1, t2)
        if i < len(lst) - n:  # skip current element
            yield from comb_with_excludes(lst, n, excludes, i+1, taken)

例子：

>>> lst = [1, 2, 3, 4, 5, 6]
>>> excludes = [{1, 3}, {1, 5}, {2, 4, 5}]
>>> list(comb_with_excludes(lst, 4, excludes))
[[1, 2, 4, 6], [2, 3, 4, 6], [2, 3, 5, 6], [3, 4, 5, 6]]

---

好吧，我现在已经计时了，结果证明这比在带有过滤器的生成器表达式中天真地使用 itertools.combination 慢得多，就像你已经做的那样：

def comb_naive(lst, r, excludes):
    return (comb for comb in itertools.combinations(lst, r)
                 if not any(e.issubset(comb) for e in excludes))

在 Python 中计算组合只是比使用库（可能在 C 中实现）并随后过滤结果要慢。根据可以排除的组合数量，这可能在某些情况下会更快，但老实说，我对此表示怀疑。

如果您可以将itertools.combinations 用于子问题（如Kasramvd's answer），您可以获得更好的结果，但对于多个非分离的排除集则更加困难。一种方法可能是将列表中的元素分成两组：有约束的，没有约束的。然后，对两者都使用itertoolc.combinations，但只检查那些重要元素的组合的约束。您仍然需要检查和过滤结果，但只是其中的一部分。 （不过需要注意的是：结果不是按顺序生成的，并且生成的组合中元素的顺序也有些混乱。）

def comb_with_excludes2(lst, n, excludes):
    wout_const = [x for x in lst if not any(x in e for e in excludes)]
    with_const = [x for x in lst if     any(x in e for e in excludes)]
    k_min, k_max = max(0, n - len(wout_const)), min(n, len(with_const))
    return (c1 + c2 for k in range(k_min, k_max)
                    for c1 in itertools.combinations(with_const, k)
                    if not any(e.issubset(c1) for e in excludes)
                    for c2 in itertools.combinations(wout_const, n - k))

这已经比递归纯 Python 解决方案好得多，但仍不如上述示例的“幼稚”方法：

>>> lst = [1, 2, 3, 4, 5, 6]
>>> excludes = [{1, 3}, {1, 5}, {2, 4, 5}]
>>> %timeit list(comb_with_excludes(lst, 4, excludes))
10000 loops, best of 3: 42.3 µs per loop
>>> %timeit list(comb_with_excludes2(lst, 4, excludes))
10000 loops, best of 3: 22.6 µs per loop
>>> %timeit list(comb_naive(lst, 4, excludes))
10000 loops, best of 3: 16.4 µs per loop

但是，结果很大程度上取决于输入。对于更大的列表，约束仅适用于其中的几个元素，这种方法实际上比简单的方法更快：

>>> lst = list(range(20))
>>> %timeit list(comb_with_excludes(lst, 4, excludes))
10 loops, best of 3: 15.1 ms per loop
>>> %timeit list(comb_with_excludes2(lst, 4, excludes))
1000 loops, best of 3: 558 µs per loop
>>> %timeit list(comb_naive(lst, 4, excludes))
100 loops, best of 3: 5.9 ms per loop

Answer 3

从算法的角度来看，您可以将有效项目的排除和重置分开，并分别计算每个集合的组合，然后根据期望长度连接结果。这种方法将完全拒绝同时包含所有排除的项目，但会省略实际的顺序。

from itertools import combinations

def comb_with_exclude(iterable, comb_num, excludes):
    iterable = tuple(iterable)
    ex_len = len(excludes)
    n = len(iterable)

    if comb_num < ex_len or comb_num > n:
        yield from combinations(iterable, comb_num)

    else:
        rest = [i for i in iterable if not i in excludes]
        ex_comb_rang = range(0, ex_len)
        rest_comb_range = range(comb_num, comb_num - ex_len, -1)
        # sum of these pairs is equal to the comb_num
        pairs = zip(ex_comb_rang, rest_comb_range)

        for i, j in pairs:
            for p in combinations(excludes, i):
                for k in combinations(rest, j):
                    yield k + p
       """
       Note that instead of those nested loops you could wrap the combinations within a product function like following:
       for p, k in product(combinations(excludes, i), combinations(rest, j)):
            yield k + p
       """

演示：

l = [1, 2, 3, 4, 5, 6, 7, 8]
ex = [2, 5, 6]
print(list(comb_with_exclude(l, 6, ex)))

[(1, 3, 4, 7, 8, 2), (1, 3, 4, 7, 8, 5), (1, 3, 4, 7, 8, 6), (1, 3, 4, 7, 2, 5), (1, 3, 4, 8, 2, 5), (1, 3, 7, 8, 2, 5), (1, 4, 7, 8, 2, 5), (3, 4, 7, 8, 2, 5), (1, 3, 4, 7, 2, 6), (1, 3, 4, 8, 2, 6), (1, 3, 7, 8, 2, 6), (1, 4, 7, 8, 2, 6), (3, 4, 7, 8, 2, 6), (1, 3, 4, 7, 5, 6), (1, 3, 4, 8, 5, 6), (1, 3, 7, 8, 5, 6), (1, 4, 7, 8, 5, 6), (3, 4, 7, 8, 5, 6)]

l = [1, 2, 3, 4, 5]
ex = [1, 3]
print(list(comb_with_exclude(l, 4, ex)))

[(2, 4, 5, 1), (2, 4, 5, 3)]

以其他答案为基准：

结果：这种方法比其他方法更快

# this answer
In [169]: %timeit list(comb_with_exclude(lst, 3, excludes[0]))
100000 loops, best of 3: 6.47 µs per loop

# tobias_k
In [158]: %timeit list(comb_with_excludes(lst, 3, excludes))
100000 loops, best of 3: 13.1 µs per loop

# Vikas Damodar
In [166]: %timeit list(combinations_exc(lst, 3))
10000 loops, best of 3: 148 µs per loop

# mikuszefski
In [168]: %timeit list(sub_without(lst, 3, excludes[0]))
100000 loops, best of 3: 12.52 µs per loop

Answer 4

我已尝试根据您的要求编辑组合：

def combinations(iterable, r):
   # combinations('ABCD', 2) --> AB AC AD BC BD CD
   # combinations(range(4), 3) --> 012 013 023 123
   pool = tuple(iterable)
   n = len(pool)
   if r > n:
      return
   indices = list(range(r))
   # yield tuple(pool[i] for i in indices)
   while True:
       for i in reversed(range(r)):
           if indices[i] != i + n - r:
               break
    else:
        return
    indices[i] += 1
    for j in range(i+1, r):
        indices[j] = indices[j-1] + 1
    # print(tuple(pool[i] for i in indices ), "hai")
    if 1 in tuple(pool[i] for i in indices ) and 3  in tuple(pool[i] for i in indices ):
        pass
    else:
        yield tuple(pool[i] for i in indices)


d = combinations(list(range(1, 6)),4)
for i in d:
   print(i)

它将返回如下内容：

(1, 2, 4, 5) (2, 3, 4, 5)

Answer 5

我在组合过程中使用以下代码进行了排除以节省第二次循环时间。您只需要将排除元素的索引作为一组传递。

更新：working fiddle

from itertools import permutations

def combinations(iterable, r, combIndeciesExclusions=set()):
    pool = tuple(iterable)
    n = len(pool)
    for indices in permutations(range(n), r):
        if ( len(combIndeciesExclusions)==0 or not combIndeciesExclusions.issubset(indices)) and sorted(indices) == list(indices):
            yield tuple(pool[i] for i in indices)


l = list(range(1, 6))
comb = combinations(l, 4, set([0,2]))
print list(comb)

Answer 6

我想我的答案与这里的其他人相似，但这是我并行摆弄的

from itertools import combinations, product

"""
with help from
https://stackoverflow.com/questions/374626/how-can-i-find-all-the-subsets-of-a-set-with-exactly-n-elements
https://stackoverflow.com/questions/32438350/python-merging-two-lists-with-all-possible-permutations
https://stackoverflow.com/questions/952914/making-a-flat-list-out-of-list-of-lists-in-python
"""
def sub_without( S, m, forbidden ):
    out = []
    allowed = [ s for s in S if s not in forbidden ]
    N = len( allowed )
    for k in range( len( forbidden ) ):
        addon = [ list( x ) for x in combinations( forbidden, k) ]
        if N + k >= m:
            base = [ list( x ) for x in combinations( allowed, m - k ) ]
            leveltotal = [ [ item for sublist in x for item in sublist ] for x in product( base, addon ) ]
            out += leveltotal
    return out

val = sub_without( range(6), 4, [ 1, 3, 5 ] )

for x in val:
    print sorted(x)

>>
[0, 1, 2, 4]
[0, 2, 3, 4]
[0, 2, 4, 5]
[0, 1, 2, 3]
[0, 1, 2, 5]
[0, 2, 3, 5]
[0, 1, 3, 4]
[0, 1, 4, 5]
[0, 3, 4, 5]
[1, 2, 3, 4]
[1, 2, 4, 5]
[2, 3, 4, 5]

Answer 7

从算法上讲，您必须计算列表中不属于排除项目的项目组合，然后将排除项目的相应组合添加到其余项目的组合中。这种方法当然需要大量检查并且需要跟踪索引，即使您在 python 中执行它也不会给您带来显着的性能差异（称为Constraint satisfaction problem 的缺点）。 （而不仅仅是使用combination 计算它们并过滤掉不需要的项目）。

因此，我认为在大多数情况下这是最好的方法：

In [77]: from itertools import combinations, filterfalse

In [78]: list(filterfalse({1, 3}.issubset, combinations(l, 4)))
Out[78]: [(1, 2, 4, 5), (2, 3, 4, 5)]