如何通过Python中非二叉树的递归深度优先搜索列出每个父节点的子节点系数?

我有一个非二叉树,其结构如下: 注: 系数仅指一个父节点中存在多少个子节点变量。因此,父节点的系数与该定义/分配无关。
注: 确切的成分是随机的。父母可以有任何数量的孩子,不同的父母可以有同一个孩子(即F和B都由E组成,但分别为1E和4E)。

我已经通过字典复制了这个结构:

dicts = {str:{str:int}}
dicts["A"] = {"B":2,"C":2,"D":1}
dicts["B"] = {"E":4}
dicts["C"] = {"F":4, "G":1}
dicts["F"] = {"E":1}
dicts["G"] = {"D":1,"E":1,"H":1}

我最终只想用底层子变量来描述每个父节点。也就是说,就“E”、“D”和“H”而言,因为它们没有进一步的子代,因此被视为底层。从数学上讲,这涉及到到达根/基层节点,并将系数乘以父层。即,对于A的左分支,它由8E组成。然后,再增加8个E(通过2C->4F->E)+再增加2个E(2C->G->E)。对“D”和“H”采取类似的方法。

由于树是非二进制的,并且可以有任何数量的具有任何深度级别的子树,我知道我必须使用递归来完成定义。

我已经成功地构建了一个正确遍历前几条腿的脚本,但当我转到其他条腿时(甚至只是先发制人地考虑更复杂、可能的结构),我发现我需要增加越来越复杂的复杂性来处理不断变化的路径。这让我觉得我处理问题的方法不对。我真的需要在递归中嵌套更多的条件句吗?或者我应该以不同的方式处理这个问题?

注: 这在正确地遍历A->2B->4E&A->2C->4F->E(导致{A:{E:16}})。

dicts = {str:{str:int}}
dicts["A"] = {"B":2,"C":2,"D":1}
dicts["B"] = {"E":4}
dicts["C"] = {"F":4, "G":1}
dicts["F"] = {"E":1}
dicts["G"] = {"D":1,"E":1,"H":1}

nullvalues = ["E","D","H"]

tempIntArray = []
tempCheckedArray = {str:[str]}
tempAnsweredArray = {str:{str:int}}
persistentN = ""

def recursive_traversal(n):
    global persistentN
    if persistentN == "":
         persistentN = n
    for x in dicts[n]:
        if n not in tempCheckedArray.keys() or x not in tempCheckedArray[n]:
            if x in nullvalues:
                product = 1
                tempIntArray.append(dicts[n][x])
                for a in tempIntArray:
                    product = a * product
                if persistentN in tempAnsweredArray.keys():
                    if x in tempAnsweredArray[persistentN].keys():
                        tempValue = tempAnsweredArray[persistentN][x] + product
                        tempAnsweredArray[persistentN][x] = tempValue
                    else:
                        tempAnsweredArray.update({persistentN:{x:product}})
                else:
                    tempAnsweredArray.update({persistentN:{x:product}})

                product = 1
                if persistentN not in tempCheckedArray.keys():
                    tempCheckedArray[persistentN] = [n]
                else:
                    tempCheckedArray[persistentN].append(n)
                tempIntArray.clear()
                return recursive_traversal(persistentN)
            else:
                tempIntArray.append(dicts[n][x])
                return recursive_traversal(x)
           

recursive_traversal("A")
print(tempAnsweredArray)

我在当前代码块中看到的唯一前进路径是添加一个检查,该检查在可解析字符串中搜索已经走过的节点路径并避免它们。类似于{“A”:[“ABBC”,“ACCFFE”]},并运行一个条件来检查路径是否已被遍历。但同样,这种做法在某种程度上感觉是错误的。