Programming languages 基于列表的树的统一算法

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

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

这里有一个例子。假设我们处理的是矩阵，所以+是可交换的，而*是非可交换的

表达式：

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

---

问：有什么标准算法可以处理这个问题吗？

当我看到这是匹配交换项的分区和子集时，我想到的就是这些。如果要将n个项与m>n个项匹配，则必须将m划分为n个部分，p

然后你需要长度p_i的子集，它可以根据你的原始模式进行测试。找到最严格的术语并首先匹配该术语可能是有意义的。e、 例如，如果mul要匹配，您可以查看是否存在mul…如果存在，则您的初始问题已分为两部分：mul部分和其余部分。最严格的术语是操作计数最高的术语。对于X+X*Y*Z+X*（Y+Z），两个mul项是并列的；这一关系可能会被打破，以支持添加更复杂内容的关系。因此，运算计数和操作类型的数量可能是复杂性度量

同理：

>>> 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中，使用SymPy.utilities.iterables中的

再次导入重塑、运行、置换

，实际上：

>>> 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']}

---

Chris

也有涉及身份矩阵

0

或

I

的情况。