带约束的分区集（使用 Python 回溯）

Question

我有一组 N 个项目，我想将它们分成 K 个大小为 n₁、n₂、...、n_{k（其中 n1 + n2 + ... + nk = N）}

我还限制了哪些项目可以属于哪个子集。

对于我的问题，至少存在一种解决方案。

我希望在 Python 中实现一种算法来生成（至少）一个解决方案。

示例：

可能性：

Item\Subset	0	1	2
A	True	True	False
B	True	True	True
C	False	False	True
D	True	True	True
E	True	False	False
F	True	True	True
G	False	False	True
H	True	True	True
I	True	True	False

尺寸限制：(3, 3, 3)

可能的解决方案：[0, 0, 2, 1, 0, 1, 2, 2, 1]

实施：

到目前为止，我已经成功地尝试了暴力破解，但我现在想找到一个更优化的算法。

我在考虑回溯，但我不确定这是正确的方法，也不确定我的实现是否正确：

import pandas as pd
import numpy as np
import string

def solve(possibilities, constraints_sizes):
    solution = [None] * len(possibilities)

    def extend_solution(position):
        possible_subsets = [index for index, value in possibilities.iloc[position].iteritems() if value]
        for subset in possible_subsets:
            solution[position] = subset
            unique, counts = np.unique([a for a in solution if a is not None], return_counts=True)
            if all(length <= constraints_sizes[sub] for sub, length in zip(unique, counts)):
                if position >= len(possibilities)-1 or extend_solution(position+1):
                    return solution
        return None

    return extend_solution(0)


if __name__ == '__main__':

    constraints_sizes = [5, 5, 6]
    
    possibilities = pd.DataFrame([[False, True, False],
                                  [True, True, True],
                                  [True, True, True],
                                  [True, True, True],
                                  [True, False, False],
                                  [True, True, True],
                                  [True, True, True],
                                  [True, True, True],
                                  [True, False, False],
                                  [True, True, True],
                                  [True, True, True],
                                  [True, True, True],
                                  [False, True, True],
                                  [True, True, True],
                                  [True, True, True],
                                  [True, False, False]],
                                 index=list(string.ascii_lowercase[:16]))
    
    solution = solve(possibilities, constraints_sizes)

一种可能的预期解决方案：[1, 0, 0, 1, 0, 1, 1, 1, 0, 2, 2, 2, 2, 2, 2, 0]

很遗憾，此代码无法找到解决方案（尽管它适用于前面的示例）。

我错过了什么？

非常感谢。

Answer 1

这个问题可以通过建立一个双向流网络来解决，其中一侧是项目，另一侧是子集，每个项目的盈余为 1，每个子集的赤字为（子集的大小），容量为 1 的弧从每个项目到它可以属于的每个子集。那么你需要这个网络上的最大流量； OR-Tools 可以做到这一点，但你有很多选择。

Answer 2

@David Eisenstat 提到 OR-Tools 作为一个包来解决这类问题。

多亏了他，我发现这个问题可以匹配他们的一个例子，Assignement with Task Sizes problem

它比我从建议的“流网络”概念中理解的更符合我对问题的理解，但我很乐意讨论这个问题。

这是我根据他们的示例实施的解决方案：

from ortools.sat.python import cp_model


def solve(possibilities, constraint_sizes):
    # Transform possibilities into costs (0 if possible, 1 otherwise)
    costs = [[int(not row[subset]) for row in possibilities] for subset in range(len(possibilities[0]))]
    
    num_subsets = len(costs)
    num_items = len(costs[0])
    
    model = cp_model.CpModel()
    
    # Variables
    x = {}
    for subset in range(num_subsets):
        for item in range(num_items):
            x[subset, item] = model.NewBoolVar(f'x[{subset},{item}]')

    # Constraints :
    # Each subset should should contain a given number of item
    for subset, size in zip(range(num_subsets), constraint_sizes):
        model.Add(sum(x[subset, item] for item in range(num_items)) <= size)
    
    # Each item is assigned to exactly one subset
    for item in range(num_items):
        model.Add(sum(x[subset, item] for subset in range(num_subsets)) == 1)
    
    # Objective
    objective_terms = []
    for subset in range(num_subsets):
        for item in range(num_items):
            objective_terms.append(costs[subset][item] * x[subset, item])
    model.Minimize(sum(objective_terms))
    
    # Solve
    solver = cp_model.CpSolver()
    status = solver.Solve(model)
    if status == cp_model.OPTIMAL or status == cp_model.FEASIBLE:
        solution = []
        for item in range(num_items):
            for subset in range(num_subsets):
                if solver.BooleanValue(x[subset, item]):
                    solution.append(subset)
        return solution
    return None

这里的诀窍是将可能性转化为成本（仅在可能的情况下为 0），并优化总成本。 一个可接受的解决方案的总成本应该为 0。

它为上一个问题提供了正确的解决方案：

possibilities = [[False, True, False],
                 [True, True, True],
                 [True, True, True],
                 [True, True, True],
                 [True, False, False],
                 [True, True, True],
                 [True, True, True],
                 [True, True, True],
                 [True, False, False],
                 [True, True, True],
                 True, True, True],
                 [True, True, True],
                 [False, True, True],
                 [True, True, True],
                 [True, True, True],
                 [True, False, False]]

constraint_sizes = [5, 5, 6]

solution = solver(possibilities, constraint_sizes)

print(solution) # [1, 2, 1, 0, 0, 0, 2, 1, 0, 1, 2, 2, 2, 2, 1, 0]

我现在还有两个问题：

• 我们能否将优化目标（最小化成本）转化为硬约束（成本应该等于 0）？我想它可以减少计算时间。

• 我怎样才能获得其他解决方案，而不仅仅是一个？

我还在寻找没有任何库的纯 Python 解决方案...

谢谢