找到加权和最小的子树的根

在树数据结构中，我们常常需要找到一个子树，使得子树中节点的加权和最小。这个问题可以通过树的遍历和动态规划的方法解决。

算法思路

我们可以先通过深度优先遍历（DFS）计算每个节点的子树加权和，然后从根节点开始，从上往下遍历每个节点，计算其子树的加权和，找到最小的子树。

具体来说，我们用一个大小为 $n$ 的数组 sum 存储每个节点的子树加权和，其中 sum[i] 表示以节点 $i$ 为根节点的子树的加权和。我们可以通过深度优先遍历计算出每个节点的子树加权和，具体实现可参考下面的伪代码：

def dfs(u, parent): # u 表示当前节点，parent 表示父节点
    sum[u] = weights[u] # 初始化 sum[u] 为节点 u 的权值
    for v in adj[u]: # 遍历节点 u 的所有子节点 v
        if v != parent: # 如果节点 v 不是节点 u 的父节点
            dfs(v, u) # 递归遍历节点 v 的子树
            sum[u] += sum[v] # 更新 sum[u]，将节点 v 的子树加权和加到 sum[u] 上

然后，我们从根节点开始遍历每个节点，计算其子树的加权和，找到最小的子树。具体实现可参考下面的伪代码：

def find_min_subtree(root):
    dfs(root, -1) # 计算每个节点的子树加权和，-1 表示根节点没有父节点
    min_sum = float('inf') # 初始化最小子树的加权和为正无穷大
    min_root = None # 初始化最小子树的根节点为 None
    for u in range(n): # 遍历每个节点
        if sum[u] < min_sum: # 如果以节点 u 为根节点的子树加权和比当前的最小值小
            min_sum = sum[u] # 更新最小值
            min_root = u # 更新最小根节点
    return min_root # 返回最小根节点

算法优化

以上算法的时间复杂度为 $O(n^2)$，其中 $n$ 表示节点数。对于大型数据集，这个算法的效率较低。

我们可以通过优化算法，将时间复杂度降为 $O(n)$。具体来说，我们可以在计算每个节点的子树加权和的同时，记录以每个节点为根节点的子树中加权和最小的节点 $t$。然后，我们从根节点开始遍历每个节点，计算其子树的加权和，如果以节点 $u$ 为根节点的子树加权和小于节点 $u$ 的子树加权和（即 $sum[u] < sum[t]$），则更新最小子树的根节点为节点 $u$。

具体实现可参考下面的伪代码：

def dfs(u, parent):
    sum[u] = weights[u]
    min_node[u] = u # 初始化以节点 u 为根的子树中最小节点为节点 u 自身
    for v in adj[u]:
        if v != parent:
            dfs(v, u)
            sum[u] += sum[v]
            if sum[v] < sum[min_node[u]]: # 如果节点 v 所在子树的加权和比记录的最小节点所在子树的加权和小
                min_node[u] = min_node[v] # 更新最小节点为 v
                # 注意：这里将更新后的最小节点 min_node[v] 赋值给 min_node[u]，这样可以保证以节点 u 为根节点的子树中最小节点的正确性

def find_min_subtree(root):
    dfs(root, -1)
    min_sum = float('inf')
    min_root = None
    for u in range(n):
        if sum[u] < min_sum: # 不再比较 sum[u] 和 sum[t] 的大小
            min_sum = sum[u]
            min_root = u
    return min_root

总结

本文介绍了如何找到加权和最小的子树的根。我们可以通过深度优先遍历计算每个节点的子树加权和，然后从根节点开始遍历每个节点，计算其子树的加权和，找到最小的子树。为了优化算法，我们可以记录以每个节点为根节点的子树中加权和最小的节点，这样可以将时间复杂度降为 $O(n)$。