Question

我需要一个统一算法来处理以下情况。

表达式树中的每个节点都有一个列表（关联）或一组（关联和交换）子节点。我希望得到所有可能的匹配特定模式。

这是一个例子。让我们假设我们正在处理矩阵，以便+是可交换的，*是非交换的

表达式：A + B*C*D + E

或者：Add(A, Mul(B, C, D), E)

模式：X + Y*Z

我看到两场比赛

X: A + E
Y: B
Z: C * D

X: A + E
Y: B * C
Z: D

问题：是否有任何标准算法可以解决这个问题？

Answer 1

当我看到这一点时，我想到的是用于匹配交换术语的分区和子集。如果你匹配n个术语到m> n术语你必须将m分成n个部分，p。

然后你想要长度为p_i的子集，然后可以根据你的原始模式进行测试。找到最具限制性的术语并首先匹配该术语可能是有意义的。例如，如果mul匹配你可以看看是否存在muls ...如果是，那么你的初始问题被分为两部分：mul部分和其余部分。限制性最强的术语是具有最高操作次数的术语。所以X + X * Y * Z + X *（Y + Z）两个mul项相关;可能会打破平局以支持Add更复杂的那个。因此，op_count和操作类型的数量可能是复杂性度量。

在SymPy中：

>>> pat = X + X*Y*Z + X*(Y+Z)
>>> [(p.count_ops(), p.count_ops(visual=True).free_symbols) for p in Add.make_args(pat)]
[(0, set([])), (2, set([MUL])), (2, set([ADD, MUL]))]

就制定映射而言，让二进制数字选择你可以使用的项目。在SymPy中再次生效from sympy.utilities.iterables import reshape, runs, permutations：

>>> N=list('ABC')
>>> M=list('abcde')
>>> n=[1]*len(N)
>>> m=[1]*len(M)
>>> n.extend([0]*(len(m) - len(n)))
>>> grouper = lambda x, xx: x==xx==0 or x==0 and xx==1
>>> demo = [1, 0, 0, 1, 1]
>>> runs(demo, grouper)
[[1, 0, 0], [1], [1]]
>>> nn=n[1:] # the first one will stay put; shuffle the rest
>>> for p in permutations(nn):
...   P = [1]+list(p)
...   shape = [[len(r)] for r in runs(P, grouper)]
...   print dict(zip(N, reshape(M, shape)[0])) 
{'A': ['a'], 'C': ['c', 'd', 'e'], 'B': ['b']}
{'A': ['a'], 'C': ['c', 'd', 'e'], 'B': ['b']}
{'A': ['a'], 'C': ['d', 'e'], 'B': ['b', 'c']}
{'A': ['a'], 'C': ['e'], 'B': ['b', 'c', 'd']}
{'A': ['a'], 'C': ['d', 'e'], 'B': ['b', 'c']}
{'A': ['a'], 'C': ['e'], 'B': ['b', 'c', 'd']}
{'A': ['a'], 'C': ['c', 'd', 'e'], 'B': ['b']}
{'A': ['a'], 'C': ['c', 'd', 'e'], 'B': ['b']}
{'A': ['a'], 'C': ['d', 'e'], 'B': ['b', 'c']}
{'A': ['a'], 'C': ['e'], 'B': ['b', 'c', 'd']}
{'A': ['a'], 'C': ['d', 'e'], 'B': ['b', 'c']}
{'A': ['a'], 'C': ['e'], 'B': ['b', 'c', 'd']}
{'A': ['a', 'b'], 'C': ['d', 'e'], 'B': ['c']}
{'A': ['a', 'b'], 'C': ['e'], 'B': ['c', 'd']}
{'A': ['a', 'b'], 'C': ['d', 'e'], 'B': ['c']}
{'A': ['a', 'b'], 'C': ['e'], 'B': ['c', 'd']}
{'A': ['a', 'b', 'c'], 'C': ['e'], 'B': ['d']}
{'A': ['a', 'b', 'c'], 'C': ['e'], 'B': ['d']}
{'A': ['a', 'b'], 'C': ['d', 'e'], 'B': ['c']}
{'A': ['a', 'b'], 'C': ['e'], 'B': ['c', 'd']}
{'A': ['a', 'b'], 'C': ['d', 'e'], 'B': ['c']}
{'A': ['a', 'b'], 'C': ['e'], 'B': ['c', 'd']}
{'A': ['a', 'b', 'c'], 'C': ['e'], 'B': ['d']}
{'A': ['a', 'b', 'c'], 'C': ['e'], 'B': ['d']}

克里斯

统一基于列表的树的算法

1 个答案: