求同级叶子数据总和的乘积 | 2套

在树形结构中，叶子节点是指没有子节点的节点。现在需要编写一个算法，求同级叶子节点数据总和的乘积。

输入

输入为一个树形结构，其中每个节点有如下信息：

• 节点id（唯一标识符）
• 节点名称
• 父节点id
• 节点数据（仅叶子节点有数据，非叶子节点数据为0）

以下是一个示例输入：

[
    {"id": 1, "name": "A", "parentId": null, "data": 0},
    {"id": 2, "name": "B", "parentId": 1, "data": 0},
    {"id": 3, "name": "C", "parentId": 1, "data": 0},
    {"id": 4, "name": "D", "parentId": 2, "data": 10},
    {"id": 5, "name": "E", "parentId": 2, "data": 5},
    {"id": 6, "name": "F", "parentId": 3, "data": 3},
    {"id": 7, "name": "G", "parentId": 3, "data": 2},
    {"id": 8, "name": "H", "parentId": 3, "data": 4}
]

输出

输出为同级叶子节点数据总和的乘积。对于上述示例，输出为 (10+5) * (3+2+4) = 120。

思路

我们可以使用深度优先遍历（DFS）的方式搜索每一个叶子节点，记录下每个叶子节点的层级深度和数据。最后，对于同一层级的叶子节点，计算它们的数据总和并相乘即可。

代码实现

根据上述思路，我们可以写出下面的Python代码实现：

def multiply_leaf_data(tree):
    leaves = []              # 存储所有叶子节点信息
    stack = [(node, 0) for node in tree if not has_children(node, tree)]   # 初始化栈，只包含叶子节点

    while stack:
        node, depth = stack.pop()
        if node['data'] == 0:   # 跳过非叶子节点
            continue
        if depth >= len(leaves):  # 如果当前层级深度还没有存储，则加入
            leaves.append([node['data']])
        else:
            leaves[depth].append(node['data'])  # 否则，加入已存储的同一层级数据

        parent_id = node['parentId']
        if parent_id is None:
            continue
        parent = get_parent_node(node, tree)
        if not parent or has_children(parent, tree):
            continue
        
        stack.append((parent, depth+1))   # 将父节点加入栈中，层级深度+1

    result = 1
    for level in leaves:
        level_total = sum(level)
        if level_total > 0:
            result *= level_total

    return result

def get_parent_node(node, tree):
    for parent in tree:
        if parent['id'] == node['parentId']:
            return parent
    return None

def has_children(node, tree):
    for child in tree:
        if child['parentId'] == node['id']:
            return True
    return False

以上代码实现了对输入tree的遍历，通过记录每个叶子节点的层级深度和数据，最终可得到同一层级叶子节点数据总和的乘积。

测试

我们对上述Python代码进行测试：

tree = [
    {"id": 1, "name": "A", "parentId": None, "data": 0},
    {"id": 2, "name": "B", "parentId": 1, "data": 0},
    {"id": 3, "name": "C", "parentId": 1, "data": 0},
    {"id": 4, "name": "D", "parentId": 2, "data": 10},
    {"id": 5, "name": "E", "parentId": 2, "data": 5},
    {"id": 6, "name": "F", "parentId": 3, "data": 3},
    {"id": 7, "name": "G", "parentId": 3, "data": 2},
    {"id": 8, "name": "H", "parentId": 3, "data": 4}
]

result = multiply_leaf_data(tree)
print(result)   # 120

以上测试代码输出了120，与预期的输出符合。