改进使用笛卡尔积的算法

Question

问题

假设您有n 整数列表，其中每个列表仅包含从1 到n 范围内的整数。例如，对于n = 4，我们可能有：

a_1 = [1, 2]
a_2 = [3]
a_3 = [4, 1, 1]
a_4 = [2, 3]

现在我的问题是：我可以勾选那些n 列表中1 和n 之间的所有整数，但是一旦我找到一个数字，我可以'不再使用该列表来查找后续数字？

例如，在上面n = 4的例子中，我可以从a_1中选择1，从a_4中选择2，从a_2中选择3，对于a_3，我可以选择4，因此我已经填写了所有从 1 到 4 的数字，但每个列表只使用一次。

我找不到范围（因此应该返回 False）的示例是：

a_1 = [1, 2]
a_2 = [3, 3, 5]
a_3 = [4]
a_4 = [5]
a_5 = [3, 4, 5]

原因是因为如果我从 a_1 中选择 1，我不能再从任何列表中选择 2。

方法

这是我目前的直截了当的方法。我制作列表的笛卡尔积并检查是否有任何排序后的范围。

import itertools

def fillRange(lists):
  cartesian = itertools.product(*lists)
  return any([sorted(comb) == range(1, len(lists) + 1) for comb in cartesian])

问题

虽然我的方法有效，但对于大型列表，它变得有点低效。关于如何改进此算法的任何想法？

谢谢！

Answer 1

您可以将其表述为二分图中的最大流问题，其中左节点对应于列表，右节点对应于整数 1 到 n。

如果整数在对应的列表中，则图中存在一条边。

图中的所有容量都等于 1。

如果你能找到从左侧到右侧的大小为 n 的流，那么问题就解决了。

下面的 Python 代码：

import networkx as nx

a_1 = [1, 2]
a_2 = [2]
a_3 = [4, 1, 1]
a_4 = [2, 3]
A = [a_1,a_2,a_3,a_4]
n = 4

G=nx.DiGraph()
for i,a in enumerate(A):
    for j in set(a):
        l = 'list'+str(i)
        G.add_edge(l,j,capacity=1)
        G.add_edge('start',l,capacity=1)
for j in range(1,n+1):
    G.add_edge(j,'dest',capacity=1)
v,flow = nx.maximum_flow(G,'start','dest')
if v<n:
    print 'Impossible'
else:
    for i,a in enumerate(A):
        for j in set(a):
            if flow['list'+str(i)][j]>0:
                print 'Use',j,'from list',a

打印出来：

Use 1 from list [1, 2]
Use 2 from list [2]
Use 4 from list [4, 1, 1]
Use 3 from list [2, 3]

Answer 2

您可以先测试最受限制的列表，然后在将元素添加到解决方案集中时更新其他列表中的备选方案，而不是按顺序测试所有组合，从而大大加快这一速度。这样，您无需回溯一次即可“解决”两个示例。

def search(n, lists):
    if n == 0:
        yield []
    else:
        lists = [l for l in lists if l != []]
        if len(lists) >= n:
            least = min(lists, key=len)
            for val in least:
                new = [[x for x in lst if x != val] for lst in lists if lst is not least]
                for res in search(n-1, new):
                    yield [val] + res

以下是您的两个示例的一些调试/跟踪输出，以帮助理解。第一个值是n，然后是lists，最后是之前选择的val。

4 [[1, 2], [3], [4, 1, 1], [2, 3]] None
3 [[1, 2], [4, 1, 1], [2]] 3
2 [[1], [4, 1, 1]] 2
1 [[4]] 1
0 [] 4 --> solution
[3, 2, 1, 4]

5 [[1, 2], [3, 3, 5], [4], [5], [3, 4, 5]] None
4 [[1, 2], [3, 3, 5], [5], [3, 5]] 4
3 [[1, 2], [3, 3], [3]] 5
2 [[1, 2], []] 3 --> abort

---

如果您还想要获取元素的列表的索引，代码会稍微复杂一些，但并不复杂：

def search(n, lists):
    if n == 0:
        yield []
    else:
        if sum(1 for l in lists if l) >= n:
            i = min(range(len(lists)), key=lambda x: (lists[x] == [], len(lists[x])))
            for val in lists[i]:
                new = [[x for x in lst if x != val] if lst is not lists[i] else [] for lst in lists]
                for res in search(n-1, new):
                    yield [(i, val)] + res

你的第一个例子的结果是[(1, 3), (3, 2), (0, 1), (2, 4)]

Answer 3

笛卡尔积对我来说似乎是最直接的。我将执行以下操作来简化您的代码：

• 如我在 cmets 中提到的，从您的 any 表达式中删除 []

• 在计算笛卡尔积之前将所有输入列表折叠到集合 - 处理同一列表中的重复值没有意义

• 将range(1, len(lists)+1) 保存到一个局部变量并与之进行比较，而不是每次都重新创建范围（这是一种称为“不变提升”的常见优化技术，其中计算的表达式在循环被“提升”出循环并且只计算一次）

但最终，计算输入列表的 a 笛卡尔的基本算法，然后查找任何值为 1-n 的值仍然是您最初编写的。

def fillRange(lists):
  cartesian = itertools.product(*(set(x) for x in lists))
  target = list(range(1, len(lists) + 1))
  return any(sorted(comb) == target for comb in cartesian)

Answer 4

这可以看作是matching in a bipartite graph的问题。事实证明，Hall's marriage theorem 告诉你答案（即匹配是否存在，而不是匹配本身）。这是一个可能的实现（为方便起见，使用 NumPy）：

from itertools import chain, combinations
import numpy as np

# Recipe from itertools docs: https://docs.python.org/3/library/itertools.html#itertools-recipes
def powerset(iterable):
    s = list(iterable)
    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))


def has_matching(lists):
    n = len(lists)
    m = np.array([np.logical_or.reduce(np.arange(1, n + 1)[:, np.newaxis] == lst, axis=1)
                  for lst in lists])
    m = m.astype(int)
    for s in powerset(range(n)):
        if np.sum(np.logical_or.reduce(m[s, :], axis=0)) < len(s):
            return False
    return True


lists1 = [[1, 2],
          [3],
          [4, 1, 1],
          [2, 3]]
print(has_matching(lists1))
>>> True

lists2 = [[1, 2],
          [3, 3, 5],
          [4],
          [5],
          [3, 4, 5]]
print(has_matching(lists2))
>>> False

但是，这需要你遍历{1, ..., n} 的每个子集，所以我猜算法是 O(2^N)。不是很好，但可能比遍历整个笛卡尔积要好，我猜应该是 O(N^N)。

Answer 5

您可以尝试映射哪些值出现在哪个列表中，然后从那里分解您的问题。这段代码构建了这种反向查找：

In[38]: from collections import defaultdict
In[39]: occurrences = defaultdict(set)
In[40]: for i,ll in enumerate(lists):
   ...:     for x in ll:
   ...:         occurrences[x].add(i)
   ...:         
In[41]: print(occurrences)
defaultdict(<class 'set'>, {1: {0, 2}, 2: {0, 3}, 3: {1, 3}, 4: {2}})
In[42]: print(dict(occurrences.items()))
{1: {0, 2}, 2: {0, 3}, 3: {1, 3}, 4: {2}}

例如，您一眼就可以看到， 4 仅存在于list[2] 中（即您原始问题中的a_3）。从那里，如果您从其他值中消除 2，则 1 仅存在于 list[0] 中。去掉0表示2只存在于list[3]中，则3只能从list[1]中得到。如果在执行此连续消除过程中，任何可供选择的集合变为空，则没有解决方案。