Python 数据结构上带记忆的递归

我正在尝试对以下问题进行记录。 数据结构如下：

ROWS = {368: [247, 257], 257: [368], 2468: [357], 357: [2468], 358: [247], 247: [358, 368]} 

它是一个字典，其中键具有列表形式的值。在每个键的列表中，元素包含与键不同的数字。示例：如果我们使用键368:[247257]，我们会发现247不包含其键368中的任何数字。257和368也是一样，数字不同

问题如下：通过使用此数据结构，构造一堵具有一定高度的墙，每个墙上都有数字，这样相邻的墙就不会有相同的数字。 例如，标高4的墙应为：

1. 368, 247, 358, 247
2. 368, 257, 368, 257 ... and so on.

问题是：高度n（在我们的例子4中）有多少种可能的组合

当从单个元素开始时，我提出了基本的递归、非常低效和不优雅的解决方案：

ROWS = {368: [247, 257], 257: [368], 2468: [357], 357: [2468], 358: [247], 
247: [358, 368]} 
SUM=0

def count_configurations( elem , rows ) :
   global SUM
   if rows == 1 :
      SUM += len(ROWS[elem])
      return len(ROWS[elem])
   else:
      for k in ROWS[elem] :
         count_configurations( k, rows-1 )

它工作得很好，但是当我们上升到一个更高的高度而没有记忆时，它会永远停留。另外，如果尝试返回count\u配置（k，rows-1）它将在第一个元素处返回，并给出错误的答案。 问题是，在处理这个问题时，我们没有像斐波那契那样的返回值，但我们会有一些其他列表的返回值。例子： 对于第4级，将类似于：

(368, 4) : [(247:3), (257:3)]   (composed of 2 elements of level 3, then 
(247:3) :  [(358:2), (368:2)]  and  (257:3) :[(368,2)] (composed of elements of level 2)

依此类推，直到我们到达第1级，在那里我们可以用实际值替换：

(368,1)=2 , (247, 1) = 1 , etc ... 

在这种情况下是否可以实施备忘录化？我是否使用了错误的数据结构，并且过度复杂？你能给我一些关于如何简化事情的建议吗

---

非常感谢。

这里的备忘录似乎很好用：

>>> from functools import lru_cache
>>>
>>> @lru_cache(None)
... def count_configurations( elem , rows ) :
...     if rows == 1 :
...         return len(ROWS[elem])
...     else:
...         return sum(count_configurations( k, rows-1 ) for k in ROWS[elem])

示例：

>>> count_configurations(247, 30)
2178309
>>> count_configurations(368, 100)
927372692193078999176
>>> count_configurations(357, 100)
1
>>> count_configurations(257, 100)
573147844013817084101