如何获得最大数量的未包含在另一个集合中的元组？

Question

给定一个字母列表，例如 L=['a','b','c','d','e','f'] 和一个元组列表，例如 T=[(' a','b'),('a','c'),('b','c')].

现在我想从 L 的列表中创建最大数量的未包含在 T 中的元组。这需要在没有重复的情况下完成，即 (a,b) 将与 (b,a) 相同。此外，每个字母只能与另一个字母匹配。

我的想法是：

#create a List of all possible tuples first:

all_tuples = [(x,y) for x in L for y in L if x!=y]

#now remove duplicates

unique_tuples = list(set([tuple(sorted(elem)) for elem in all_tuples]))

#Now, create a new set that matches each letter only once with another letter

visited=set()
output = []

for letter1, letter2 in unique tuples:
   if ((letter1, letter2) or (letter2, letter1)) in T:
      continue
   
   if not letter1 in visited and not letter2 in visited:
      visited.add(letter1)
      visited.add(letter2)
      output.append((letter1,letter2))

print(output)

然而，这并不总是给出可能的元组的最大数量，这取决于 T 是什么。例如，假设我们提取可能的 unique_tuples=[('a','b'),('a','d'),('b','c')]。

如果我们先将 ('a','b') 附加到我们的输出中，我们将无法再附加 ('b','c')，因为 'b' 已经匹配。但是，如果我们先附加 ('a','d')，我们也可以在之后得到 ('b','c') 并获得最大数量的两个元组。

如何解决这个问题？

Answer 1

如果我们忽略两次不匹配同一个字母的业务，这是combinations的直接用法：

>>> from itertools import combinations
>>> L=['a','b','c','d','e','f']
>>> T=[('a','b'),('a','c'),('b','c')]
>>> [t for t in combinations(L, 2) if t not in T]
[('a', 'd'), ('a', 'e'), ('a', 'f'), ('b', 'd'), ('b', 'e'), ('b', 'f'), ('c', 'd'), ('c', 'e'), ('c', 'f'), ('d', 'e'), ('d', 'f'), ('e', 'f')]

如果我们限制自己只使用每个字母一次，问题就很简单了，因为我们知道我们最多只能有 (letters / 2) 个元组。只需找到可用的字母（通过减去 T 中已经存在的字母），然后以任意顺序将它们配对。

>>> used_letters = {c for t in T for c in t}
>>> free_letters = [c for c in L if c not in used_letters]
>>> [tuple(free_letters[i:i+2]) for i in range(0, 2 * (len(free_letters) // 2), 2)]
[('d', 'e')]

Answer 2

不使用库，你可以这样做：

L=['a','b','c','d','e','f']
T=[('a','b'),('a','c'),('b','c')]

L = sorted(L,key=lambda c: -sum(c in t for t in T))
used = set()
r = [(a,b) for i,a in enumerate(L) for b in L[i+1:]
     if (a,b) not in T and (b,a) not in T
     and used.isdisjoint((a,b)) and not used.update((a,b))]

print(r)
[('a', 'd'), ('b', 'e'), ('c', 'f')]

字母在组合之前按 T 中的频率降序排列。这可确保首先处理最难匹配的字母，从而最大限度地提高剩余字母的配对潜力。

或者，您可以使用递归 (DP) 方法并检查所有可能的配对组合。

def maxTuples(L,T):
    maxCombos = []                          # will return longest
    for i,a in enumerate(L):                # first letter of tuple
        for j,b in enumerate(L[i+1:],i+1):  # second letter of tuple
            if (a,b) in T: continue         # tuple not in T
            if (b,a) in T: continue         # inverted tuple not in T
            rest = L[:i]+L[i+1:j]+L[j+1:]   # recurse with rest of letters
            R = [(a,b)]+maxTuples(rest,T)   # adding to selected pair
            if len(R)*2+1>=len(L): return R # max possible, stop here
            if len(R)>len(maxCombos):       # longer combination of tuples
                maxCombos = R               # Track it
    return maxCombos

...

L=['a','b','c','d','e','f']
T=[('a','b'),('a','c'),('b','c'),('c','f')]

print(maxTuples(L,T))        

[('a', 'd'), ('b', 'f'), ('c', 'e')]


L = list("ABCDEFGHIJKLMNOP")
T = [('K', 'N'), ('G', 'F'), ('I', 'P'), ('C', 'A'), ('O', 'M'), 
     ('D', 'B'), ('L', 'J'), ('E', 'H'), ('F', 'E'), ('L', 'H'), 
     ('J', 'G'), ('N', 'I'), ('C', 'M'), ('A', 'P'), ('D', 'O'), 
     ('K', 'B'), ('G', 'H'), ('O', 'A'), ('I', 'J'), ('N', 'M'), 
     ('F', 'P'), ('E', 'B'), ('K', 'L'), ('D', 'C'), ('D', 'E'), 
     ('L', 'F'), ('B', 'H'), ('I', 'A'), ('K', 'G'), ('M', 'O'), 
     ('P', 'C'), ('N', 'J'), ('J', 'E'), ('N', 'P'), ('A', 'G'), 
     ('H', 'O'), ('I', 'B'), ('K', 'F'), ('M', 'C'), ('L', 'D'), 
     ('A', 'B'), ('C', 'E'), ('D', 'F'), ('G', 'I'), ('H', 'J'), 
     ('K', 'M'), ('L', 'N'), ('O', 'P')]

print(maxTuples(L,T))        

[('A', 'D'), ('B', 'C'), ('E', 'G'), ('F', 'H'), 
 ('I', 'K'), ('J', 'M'), ('L', 'P'), ('N', 'O')]

请注意，如果 T 中的元组排除了太多配对以致无法生成 len(L)/2 个元组的组合，则该函数会很慢。它可以通过过滤在递归过程中完全排除的字母来进一步优化：

def maxTuples(L,T):
    if not isinstance(T,dict):        
        T,E = {c:{c} for c in L},T               # convert T to a dictionary
        for a,b in E: T[a].add(b);T[b].add(a)    # of excluded letter sets
    L = [c for c in L if not T[c].issuperset(L)] # filter fully excluded   
    maxCombos = []                          # will return longest
    for i,a in enumerate(L):                # first letter of tuple
        for j,b in enumerate(L[i+1:],i+1):  # second letter of tuple
            if b in T[a]: continue          # exclude tuples in T
            rest = L[:i]+L[i+1:j]+L[j+1:]   # recurse with rest of letters
            R = [(a,b)]+maxTuples(rest,T)   # adding to selected pair
            if len(R)*2+1>=len(L): return R # max possible, stop here
            if len(R)>len(maxCombos):       # longer combination of tuples
                maxCombos = R               # Track it
    return maxCombos