N-ary Tree 中任意两级总和的最大绝对差

在 N-ary Tree 中找到任意两个层级的节点值之和之间的最大绝对差。

可以将 N 叉树看作一个根节点下有若干个子树的结构，每个子树就是一个 N 叉树。

例如，下面的 N 叉树包含 3 个子树：

按照题目描述来说，给定这个树，如果选择第一层和第三层，那么节点值之和之间的最大绝对差就是 18。

算法思路

由于是要比较任意两级之间的节点值之和，我们可以采用递归的方法。

从根节点开始递归，记录每个节点的层数以及该层节点值之和。当递归到叶子节点时，我们就可以得到每个层级的节点值之和。再对每一层节点值之和进行比较，求出最大绝对差即可。

复杂度分析

• 时间复杂度：$O(N)$，其中 N 表示树中节点的个数。每个节点遍历一次。
• 空间复杂度：$O(H)$，其中 H 表示树的高度。递归栈的深度随着树的高度而变化。

代码实现

Python 代码实现如下：

class Solution:
    def maxLevelSum(self, root: TreeNode) -> int:
        level_sum = []
        self._dfs(root, 1, level_sum)
        max_diff = max(level_sum) - min(level_sum)
        return level_sum.index(max(level_sum)) + 1 if level_sum.count(max(level_sum)) == 1 else -1
        
    def _dfs(self, node, level, level_sum):
        if not node:
            return
        if len(level_sum) < level:
            level_sum.append(node.val)
        else:
            level_sum[level - 1] += node.val
        for child in node.children:
            self._dfs(child, level + 1, level_sum)

Java 代码实现如下：

class Solution {
    public int maxLevelSum(Node root) {
        List<Integer> levelSum = new ArrayList<>();
        dfs(root, 1, levelSum);
        int maxDiff = Collections.max(levelSum) - Collections.min(levelSum);
        return levelSum.indexOf(Collections.max(levelSum)) + 1 == Collections.frequency(levelSum, Collections.max(levelSum)) ? levelSum.indexOf(Collections.max(levelSum)) + 1 : -1;
    }
    
    private void dfs(Node node, int level, List<Integer> levelSum) {
        if (node == null) {
            return;
        }
        if (levelSum.size() < level) {
            levelSum.add(node.val);
        } else {
            levelSum.set(level - 1, levelSum.get(level - 1) + node.val);
        }
        for (Node child : node.children) {
            dfs(child, level + 1, levelSum);
        }
    }
}

以上就是求解 N-ary Tree 中任意两级总和的最大绝对差的算法实现及复杂度分析。