1

我正在尝试解决来自生物学领域的一个问题，在这个问题中，我必须结合每个大元素的局部次优解决方案，以便每个子粒子都是独一无二的。问题是可能性可以扩展到 +4.000 局部次优解决方案和 +30.000 元素。笛卡尔积不是一个选项，因为组合列表是一个n*m*p*......问题，如果没有超越itertools.

一般架构是：

[
  [ [a,b,c],[d,e,a],[f], ...],
  [ [f,e,t],[a,b,t],[q], ...],
  [ [a,e,f],[],[p], ... up to 4.000],
  ... up to 30.000
]

[ [a,b,c],[d,e,a],[f],.....],-> 一组 elem 的次优解决方案。#1

我想尽快找到

  • 第一：一个解决方案，这意味着每个元素的一个次优解决方案的组合（可能包括空白列表），这样就没有重复项。例如 [[a,b,c],[f,e,t][p]]。

  • 第二：所有兼容的解决方案。

我知道这是一个悬而未决的问题，但是我需要一些指导或一般算法来解决这个问题，如果我有什么要开始的，我可以进一步调查。

我在其余的实验室工作中使用 python，但是我对其他语言持开放态度。

我们可以从一个基本的求解器开始，该求解器在总的次优和列表数量方面处理较少的可能性。

最好的。

编辑 1

一个非常简短的真实示例：

[[[1,2,3][1,2,4],[1,2,5],[5,8]],
[[1,3][7,8],[6,1]],
[[]],
[[9,10][7,5],[6,9],[6,10]]]

最佳解决方案（来自第 # 行）：

#1 [1,2,3]
#2 [7,8]
#3 [9,10]

Output: [[1,2,3],[7,8],[9,10]]

可以看这里https://pastebin.com/qq4k2FdW

4

1 回答 1

0

这里有几个算法。您可以非常简单地使用 itertools 对所有可能的组合进行蛮力搜索：

from itertools import product, chain

def get_compatible_solutions(subsolutions):
    for sol in product(*subsolutions):
        if len(set(chain.from_iterable(sol))) == sum(map(len, sol)):
            yield sol

# Test
example = [
    [[1, 2, 3], [1, 2, 4], [1, 2, 5], [5, 8]],
    [[1, 3], [7, 8], [6, 1]],
    [[]],
    [[9, 10], [7, 5], [6, 9], [6, 10]]
]

# Get one solution
print(next(get_compatible_solutions(example)))
# ([1, 2, 3], [7, 8], [], [9, 10])

# Get all solutions
print(*get_compatible_solutions(example), sep='\n')
# ([1, 2, 3], [7, 8], [], [9, 10])
# ([1, 2, 3], [7, 8], [], [6, 9])
# ([1, 2, 3], [7, 8], [], [6, 10])
# ([1, 2, 4], [7, 8], [], [9, 10])
# ([1, 2, 4], [7, 8], [], [6, 9])
# ([1, 2, 4], [7, 8], [], [6, 10])
# ([1, 2, 5], [7, 8], [], [9, 10])
# ([1, 2, 5], [7, 8], [], [6, 9])
# ([1, 2, 5], [7, 8], [], [6, 10])
# ([5, 8], [1, 3], [], [9, 10])
# ([5, 8], [1, 3], [], [6, 9])
# ([5, 8], [1, 3], [], [6, 10])
# ([5, 8], [6, 1], [], [9, 10])

另一种可能性是一次进行一行递归搜索。这将探索比笛卡尔积更少的候选解决方案，因为一旦从搜索路径中排除次优解决方案，就不会处理包括它在内的任何组合。

def get_compatible_solutions(subsolutions):
    current = [None] * len(subsolutions)
    seen = set()
    yield from _get_compatible_solutions_rec(subsolutions, current, 0, seen)

def _get_compatible_solutions_rec(subsolutions, current, i, seen):
    if i >= len(subsolutions):
        yield tuple(current)
    else:
        for subsol in subsolutions[i]:
            if any(s in seen for s in subsol):
                continue
            seen.update(subsol)
            current[i] = subsol
            yield from _get_compatible_solutions_rec(subsolutions, current, i + 1, seen)
            seen.difference_update(subsol)
于 2019-08-01T16:56:40.573 回答