Question

我正在寻找以下问题的快速算法。

规则由关于元组的子句的连接表示。子句指定两个元组项之间的关系。例如T(1)[2] = T(3)[1]表示：the second item in the first tuple must be equal to the first one in the third。

所以规则可以是：T(1)[2] = T(3)[1] AND T(1)[1] > T(2)[1]

通用规则：

条款：(T(j)[i] op T(k)[l])
条件：Clause (AND Clause)*
支持的运营商：=，!=，>，<，<=，>=

算法在每个项目都是数字的形式中接收这样的规则和元组列表：

(i11 i12 ... i1n)
...
(ik1 ik2 ... ikm)

元组的长度不同，数量不详。列表中的元组可以按任何顺序排列。

算法将从输入中输出符合规则的元组的所有组合。

示例：

规则：T(1)[1] = T(2)[1] AND T(1)[3]>T(3)[1]

元组：

`(1 2 3 4)`   T1
`(3 2 4)'     T2
`(4)`         T3
`(1 5 3 6 7)` T4

将输出以下组合：

T(1): T1, T(2): T4, T(3): T2
T(1): T4, T(2): T1, T(3): T2

基本上它会识别哪些元组可以替换每个T（i），以便它的规则为真。

有一个众所周知的快速执行此算法吗？有什么建议吗？

谢谢，

A

Answer 1

由于您需要列出所有可能的分配，而不是计算它们的数量，例如，这可能更容易（虽然我不这么认为），唯一的方法可能是实施backtracking解决方案。

编辑：具体来说，因为原始列表中存在N!个排列（其中N是元组数），这可能满足约束条件（在最坏的情况下）），你需要列出那些，O(N!)的上限很紧。

Answer 2

您可以将其实现为constraint模块的包装器。以下是您问题中示例的解决方案：

#!/usr/bin/env python
from constraint import AllDifferentConstraint, Problem

number_of_variables = 3
variables = ["T(%d)" % i for i in range(1, number_of_variables+1)]
possible_values = [(1, 2, 3, 4), (3, 2, 4), (4,), (1, 5, 3, 6, 7)]

problem = Problem()
problem.addVariables(variables, possible_values)
# each tuple should occur only once in the solution
problem.addConstraint(AllDifferentConstraint(), variables)
# T(1)[1] = T(2)[1] rule
problem.addConstraint(lambda a, b: len(a) > 0 and len(b) > 0 and a[0] == b[0],
                      "T(1) T(2)".split())
# T(1)[3] >= T(3)[1] rule 
problem.addConstraint(lambda a, b: len(a) > 2 and len(b) > 0 and a[2] >= b[0],
                      "T(1) T(3)".split()) # implicit AND

short_names = dict((val, "T%d" % i) for i, val in enumerate(possible_values, 1))
for solution in problem.getSolutionIter():
    print ", ".join("%s: %s" % (variable, short_names[value])
                    for variable, value in sorted(solution.iteritems()))

输出

T(1): T4, T(2): T1, T(3): T2
T(1): T1, T(2): T4, T(3): T2

您可以将规则组合到单个约束中：

# T(1)[1] = T(2)[1] AND T(1)[3] >= T(3)[1]
problem.addConstraint(lambda a, b, c: (len(a) > 2 and b and c and
                                       a[0] == b[0] and a[2] >= c[0]),
                      variables)

要安装constraint模块，请键入：

$ pip install http://labix.org/download/python-constraint/python-constraint-1.1.tar.bz2

Answer 3

我认为你正在寻找类似于Rete算法中的Beta网络http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.83.4551&rep=rep1&type=pdf

根据条件快速匹配元组

3 个答案:

输出