二叉树最大路径和算法答案

【问题标题】：Binary Tree Maximum Path Sum Algorithm二叉树最大路径和算法
【发布时间】：2020-11-29 11:15:40
【问题描述】：

我是递归和二叉树的新手。我正在尝试解决 leetcode 上的this problem。

求最大和路径就像求任意两个节点之间的最大路径，该路径可能经过也可能不经过根节点；除了最大和路径我们想要跟踪总和而不是路径长度。

我的算法通过了 91/93 个测试用例，但我无法弄清楚我缺少什么。谁能给点方向？

class Solution {
    private int sum = Integer.MIN_VALUE;
    public int maxPathSum(TreeNode root) {
        maxPathSumHelper(root);
        if(root.left != null){
            maxPathSumHelper(root.left);
        }
        if(root.right != null){
            maxPathSumHelper(root.right);
        }
        
        return sum;
    }
    public int  maxPathSumHelper(TreeNode root){
        if(root ==  null){
            return 0;
        }
        //check left sum
        int leftValue = root.val + maxPathSumHelper(root.left);
        if(leftValue > sum){
            sum = leftValue;
        }
        //check right sum
        int rightValue = root.val + maxPathSumHelper(root.right);
        if(rightValue > sum){
            sum = rightValue;
        }
        //check if root value is greater 
        if(root.val > sum){
            sum = root.val;
        }
        //check if right and left value is the greatest
        if((leftValue + rightValue - (2 * root.val) )+ root.val > sum){
            sum = (leftValue + rightValue - (2 * root.val)) + root.val;
        }
        return Math.max(leftValue, rightValue);
    }
}

【问题讨论】：

对我来说，这个任务看起来更像是一个最大和子树，而不是一条路径。

标签： java algorithm recursion binary-tree

【解决方案1】：

试试

class Solution {
    private int sum = Integer.MIN_VALUE;
    public int maxPathSum(TreeNode root) {
        maxPathSumHelper(root);

        if (root.left != null) {
            maxPathSumHelper(root.left);

        } else if (root.right != null) {
            maxPathSumHelper(root.right);

        }

        return sum;
    }
    public int  maxPathSumHelper(TreeNode root) {
        if (root ==  null) {
            return 0;
        }

        //check left sum
        int leftValue = root.val + maxPathSumHelper(root.left);

        if (leftValue > sum) {
            sum = leftValue;
        }

        //check right sum
        int rightValue = root.val + maxPathSumHelper(root.right);

        if (rightValue > sum) {
            sum = rightValue;
        }

        //check if root value is greater
        if (root.val > sum) {
            sum = root.val;
        }

        //check if right and left value is the greatest
        if ((leftValue + rightValue - (2 * root.val) ) + root.val > sum) {
            sum = (leftValue + rightValue - (2 * root.val)) + root.val;
        }

        return Math.max(Math.max(leftValue, rightValue), root.val);
    }
}

【讨论】：

【解决方案2】：

我想我们可以在这里简化一下我们的陈述。

这只会被接受：

public final class Solution {
    int max;

    public final int maxPathSum(final TreeNode root) {
        max = Integer.MIN_VALUE;
        traverse(root);
        return max;
    }

    private final int traverse(final TreeNode node) {
        if (node == null)
            return 0;
        final int l = Math.max(0, traverse(node.left));
        final int r = Math.max(0, traverse(node.right));
        max = Math.max(max, l + r + node.val);
        return Math.max(l, r) + node.val;
    }
}

参考

更多详细信息，请参阅Discussion Board，您可以在其中找到大量解释清楚且公认的解决方案，其中包含多种languages，包括高效算法和渐近time/space 复杂性分析^1,2.

【讨论】：

这似乎没有考虑负节点值，是吗？
@Emma 感谢您简化我复杂的陈述并花时间提供步骤。尽管我在语句的逻辑上看到了相似之处，但我仍在试图找出我错过的哪些比较导致算法失败。你能帮我解决这个问题吗？谢谢。
@Suman 谢谢我想我错过了应该返回leftsum或rightsum或left + right + root的事实。我想我现在明白了。谢谢艾玛和苏曼。这两种解决方案都能帮助我理解。