从列表的元素中查找互斥集的python组合

Question

在我目前正在进行的一个项目中，我已经实现了大约 80% 的我希望我的程序执行的操作，我对结果非常满意。

在剩下的 20% 中，我遇到了一个让我有点不知道如何解决的问题。 这里是：

我提出了一个列表列表，其中包含多个数字（任意长度） 例如：

listElement[0] = [1, 2, 3]
listElement[1] = [3, 6, 8]
listElement[2] = [4, 9]
listElement[4] = [6, 11]
listElement[n] = [x, y, z...]

其中 n 可以达到 40,000 左右。

假设每个列表元素是一组数字（在数学意义上），我想做的是推导出互斥集合的所有组合；也就是说，类似于上述列表元素的幂集，但排除了所有非不相交集元素。

因此，为了继续 n=4 的示例，我想提出一个包含以下组合的列表：

newlistElement[0] = [1, 2, 3]
newlistElement[1] = [3, 6, 8]
newlistElement[2] = [4, 9]
newlistElement[4] = [6, 11] 
newlistElement[5] = [[1, 2, 3], [4, 9]]
newlistElement[6] = [[1, 2, 3], [6, 11]]
newlistElement[7] = [[1, 2, 3], [4, 9], [6, 11]]
newlistElement[8] = [[3, 6, 8], [4, 9]]
newlistElement[9] = [[4, 9], [6, 11]

一个无效的情况，例如组合 [[1, 2, 3], [3, 6, 8]] 因为 3 在两个元素中是常见的。 有什么优雅的方法可以做到这一点吗？如有任何反馈，我将不胜感激。

我还必须说明我不想执行 powerset 函数，因为初始列表可能有相当多的元素（正如我所说的 n 可以达到 40000），并且使用这么多元素的 powerset永远不会完成。

Answer 1

我会使用生成器：

import itertools

def comb(seq):
   for n in range(1, len(seq)):
      for c in itertools.combinations(seq, n): # all combinations of length n
         if len(set.union(*map(set, c))) == sum(len(s) for s in c): # pairwise disjoint?
            yield list(c)

for c in comb([[1, 2, 3], [3, 6, 8], [4, 9], [6, 11]]):
   print c

这会产生：

[[1, 2, 3]]
[[3, 6, 8]]
[[4, 9]]
[[6, 11]]
[[1, 2, 3], [4, 9]]
[[1, 2, 3], [6, 11]]
[[3, 6, 8], [4, 9]]
[[4, 9], [6, 11]]
[[1, 2, 3], [4, 9], [6, 11]]

如果您需要将结果存储在单个列表中：

print list(comb([[1, 2, 3], [3, 6, 8], [4, 9], [6, 11]]))

Answer 2

以下是递归生成器：

def comb(input, lst = [], lset = set()):
   if lst:
      yield lst
   for i, el in enumerate(input):
      if lset.isdisjoint(el):
         for out in comb(input[i+1:], lst + [el], lset | set(el)):
            yield out

for c in comb([[1, 2, 3], [3, 6, 8], [4, 9], [6, 11]]):
   print c

在许多集合具有共同元素的情况下，这可能比其他解决方案更有效（当然在最坏的情况下，它仍然必须遍历 powerset 的 2**n 元素）。

Answer 3

下面程序中使用的方法类似于之前的几个答案，排除了不相交的集合，因此通常不会测试所有组合。它与以前的答案不同，它尽可能早地贪婪地排除所有集合。这使其运行速度比 NPE 的解决方案快几倍。这是两种方法的时间比较，使用的输入数据有 200、400、... 1000 个大小为 6 的集合，其元素范围为 0 到 20：

Set size =   6,  Number max =  20   NPE method
  0.042s  Sizes: [200, 1534, 67]
  0.281s  Sizes: [400, 6257, 618]
  0.890s  Sizes: [600, 13908, 2043]
  2.097s  Sizes: [800, 24589, 4620]
  4.387s  Sizes: [1000, 39035, 9689]

Set size =   6,  Number max =  20   jwpat7 method
  0.041s  Sizes: [200, 1534, 67]
  0.077s  Sizes: [400, 6257, 618]
  0.167s  Sizes: [600, 13908, 2043]
  0.330s  Sizes: [800, 24589, 4620]
  0.590s  Sizes: [1000, 39035, 9689]

在上面的数据中，左列显示了以秒为单位的执行时间。数字列表显示发生了多少个单联、双联或三联。程序中的常量指定数据集的大小和特征。

#!/usr/bin/python
from random import sample, seed
import time
nsets,   ndelta,  ncount, setsize  = 200, 200, 5, 6
topnum, ranSeed, shoSets, shoUnion = 20, 1234, 0, 0
seed(ranSeed)
print 'Set size = {:3d},  Number max = {:3d}'.format(setsize, topnum)

for casenumber in range(ncount):
    t0 = time.time()
    sets, sizes, ssum = [], [0]*nsets, [0]*(nsets+1);
    for i in range(nsets):
        sets.append(set(sample(xrange(topnum), setsize)))

    if shoSets:
        print 'sets = {},  setSize = {},  top# = {},  seed = {}'.format(
            nsets, setsize, topnum, ranSeed)
        print 'Sets:'
        for s in sets: print s

    # Method by jwpat7
    def accrue(u, bset, csets):
        for i, c in enumerate(csets):
            y = u + [c]
            yield y
            boc = bset|c
            ts = [s for s in csets[i+1:] if boc.isdisjoint(s)]
            for v in accrue (y, boc, ts):
                yield v

    # Method by NPE
    def comb(input, lst = [], lset = set()):
        if lst:
            yield lst
        for i, el in enumerate(input):
            if lset.isdisjoint(el):
                for out in comb(input[i+1:], lst + [el], lset | set(el)):
                    yield out

    # Uncomment one of the following 2 lines to select method
    #for u in comb (sets):
    for u in accrue ([], set(), sets):
        sizes[len(u)-1] += 1
        if shoUnion: print u
    t1 = time.time()
    for t in range(nsets-1, -1, -1):
        ssum[t] = sizes[t] + ssum[t+1]
    print '{:7.3f}s  Sizes:'.format(t1-t0), [s for (s,t) in zip(sizes, ssum) if t>0]
    nsets += ndelta

编辑：在函数accrue中，参数(u, bset, csets)使用如下：
• u = 当前集合并集中的集合列表
• bset = "big set" = u 的平面值 = 已使用的元素
• csets = 候选集 = 符合条件的集列表
注意如果accrue的第一行被替换为
def accrue(csets, u=[], bset=set()):
第七行 by
for v in accrue (ts, y, boc):
（即，如果重新排序参数并为 u 和 bset 提供默认值）然后可以通过 [accrue(listofsets)] 调用 accrue 以生成其兼容联合列表。

关于评论中提到的ValueError: zero length field name in format错误是在使用Python 2.6时发生的，请尝试以下操作。

# change:
    print "Set size = {:3d}, Number max = {:3d}".format(setsize, topnum)
# to:
    print "Set size = {0:3d}, Number max = {1:3d}".format(setsize, topnum)

程序中的其他格式可能需要进行类似的更改（添加适当的字段编号）。请注意，what's new in 2.6 页面显示“对 str.format() 方法的支持已向后移植到 Python 2.6”。虽然它没有说明是否需要字段名称或数字，但它没有显示没有它们的示例。相比之下，任何一种方式都适用于 2.7.3。

Answer 4

使用itertools.combinations、set.intersection 和for-else 循环：

from itertools import *
lis=[[1, 2, 3], [3, 6, 8], [4, 9], [6, 11]]
def func(lis):
    for i in range(1,len(lis)+1):
       for x in combinations(lis,i):
          s=set(x[0])
          for y in x[1:]:
              if len(s & set(y)) != 0:
                  break
              else:
                  s.update(y)    
          else:
              yield x


for item in func(lis):
    print item

输出：

([1, 2, 3],)
([3, 6, 8],)
([4, 9],)
([6, 11],)
([1, 2, 3], [4, 9])
([1, 2, 3], [6, 11])
([3, 6, 8], [4, 9])
([4, 9], [6, 11])
([1, 2, 3], [4, 9], [6, 11])

Answer 5

类似于NPE's solution，但它没有递归，它返回一个列表：

def disjoint_combinations(seqs):
    disjoint = []
    for seq in seqs:
        disjoint.extend([(each + [seq], items.union(seq))
                            for each, items in disjoint
                                if items.isdisjoint(seq)])
        disjoint.append(([seq], set(seq)))
    return [each for each, _ in disjoint]

for each in disjoint_combinations([[1, 2, 3], [3, 6, 8], [4, 9], [6, 11]]):
    print each

结果：

[[1, 2, 3]]
[[3, 6, 8]]
[[1, 2, 3], [4, 9]]
[[3, 6, 8], [4, 9]]
[[4, 9]]
[[1, 2, 3], [6, 11]]
[[1, 2, 3], [4, 9], [6, 11]]
[[4, 9], [6, 11]]
[[6, 11]]

Answer 6

不使用 itertools 包的单行程序。 这是您的数据：

lE={}
lE[0]=[1, 2, 3]
lE[1] = [3, 6, 8]
lE[2] = [4, 9]
lE[4] = [6, 11]

这是单行：

results=[(lE[v1],lE[v2]) for v1 in lE for v2  in lE if (set(lE[v1]).isdisjoint(set(lE[v2])) and v1>v2)]