国际空间研究组织 (ISRO) CS 2020 - 问题 11

这篇文章介绍了国际空间研究组织 (ISRO) CS 2020 的问题 11。该问题关于一个具有 n 个节点的二叉树，计算其所有节点到最远叶节点的距离之和。

问题描述

给定一个具有 n 个节点的二叉树，计算其所有节点到最远叶节点的距离之和。

输入格式

输入的第一行包含一个整数 n，表示二叉树的节点数。

接下来 n 行，每行描述二叉树的一个节点，第 i 行表示第 i 个节点的左子节点编号（如果没有左子节点则为 0），右子节点编号（如果没有右子节点则为 0），和节点权值。

输出格式

输出一个整数，表示所有节点到最远叶节点的距离之和。

输入样例

5
2 3 5
4 0 2
5 0 6
0 0 1
0 0 4

输出样例

32

数据范围

1 ≤ n ≤ 10^5

解题思路

通过遍历整个二叉树，我们可以找到每个节点到其最远叶节点的距离。然后，我们可以将这些距离相加，以获得所有节点到最远叶节点的距离之和。

对于每个节点，我们可以使用深度优先搜索 (DFS) 来计算它到最远叶节点的距离。具体来说，我们可以使用 DFS 来计算一个节点的深度，并在计算该节点的子节点的深度时，同时计算该节点到最远叶节点的距离。我们可以在 DFS 的同时更新每个节点的深度和到最远叶节点的距离，以避免重复计算。

具体实现可以在遍历树时使用递归函数来完成。函数的输入参数包括当前节点、当前节点的父节点和当前节点到父节点的距离。如果当前节点是叶节点，则我们可以直接返回该节点到其父节点的距离，即当前节点到最远叶节点的距离为 0。否则，我们可以递归地计算当前节点的左右子树的深度和到最远叶节点的距离，然后将它们相加，加上当前节点到父节点的距离，即可得到该节点到最远叶节点的距离。

代码实现

下面是一个 Python 代码实现。

class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None
        
class Solution:
    def sum_of_distances(self, n: int, edges: List[List[int]]) -> List[int]:
        # 构建二叉树
        nodes = [TreeNode(i) for i in range(n)]
        for i, j in edges:
            if nodes[i].left is None:
                nodes[i].left = nodes[j]
            else:
                nodes[i].right = nodes[j]
        
        # 记录每个节点到其最远叶节点的距离
        dists = [0] * n
        
        # 记录每个节点的子树大小
        sizes = [0] * n
        
        # 记录每个节点的深度
        depths = [0] * n
        
        # 记录每个节点的父节点
        parents = [None] * n
        
        # 记录每个节点的子节点
        children = [[] for i in range(n)]
        
        # 计算每个节点的子树大小、深度和到最远叶节点的距离
        def dfs1(node: TreeNode, parent: TreeNode):
            if node is None:
                return
            
            parents[node.val] = parent
            
            if node.left is None and node.right is None:
                dists[node.val] = 0
                sizes[node.val] = 1
                depths[node.val] = 0
                return
            
            dfs1(node.left, node)
            dfs1(node.right, node)
            
            sizes[node.val] = sizes[node.left] + sizes[node.right] + 1
            depths[node.val] = max(depths[node.left], depths[node.right]) + 1
            
            if sizes[node.left] > sizes[node.right]:
                dists[node.val] = dists[node.left] + sizes[node.right] + 1
                children[node.left].append(node)
            else:
                dists[node.val] = dists[node.right] + sizes[node.left] + 1
                children[node.right].append(node)
                
        dfs1(nodes[0], None)
        
        # 计算每个节点到其它节点的距离
        def dfs2(node: TreeNode):
            if node is None:
                return
            
            for child in children[node.val]:
                dists[child.val] = dists[node.val] - sizes[child.val] + (n - sizes[child.val])
                dfs2(child)
                
        dfs2(nodes[0])
        
        return dists

该代码首先根据给定的边缘列表构建了一棵二叉树，并使用 DFS 在每个节点上计算其到最远叶节点的距离和其它相关信息。然后，使用 DFS 再次遍历整个树，并计算每个节点到其它节点的距离。最后，返回所有节点到最远叶节点的距离之和。