二叉树中的最大路径和

二叉树中的 路径 被定义为一条节点序列，序列中每对相邻节点之间都存在一条边。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个 节点，且不一定经过根节点。

路径和 是路径中各节点值的总和。

给你一个二叉树的根节点 root ，返回其 最大路径和 。

示例 1：

输入：root = [1,2,3]
输出：6
解释：最优路径是 2 -> 1 -> 3 ，路径和为 2 + 1 + 3 = 6

示例 2：

输入：root = [-10,9,20,null,null,15,7]
输出：42
解释：最优路径是 15 -> 20 -> 7 ，路径和为 15 + 20 + 7 = 42

题解

对于树的题目，有统一的思考方法，那就是站在树（子树）的顶端根节点root思考。

那么对于此题，我们思考如下问题：如果当前处在root节点，左右节点应该告诉我们什么信息才能得到答案？

根据题中对路径的定义，对于此题我们来回答以上问题。当我们遍历到树中某个节点时，我希望左子节点告诉我，在左子树中，以左子节点为开始（端点）的路径和最大为多少，同理我也希望右子节点告诉我类似的信息。

如果有了以上信息，再来思考最后一个问题：有了这个信息如何得到答案？

显然，对于当前节点有四个选择：

我自己就是一条路径只跟左子节点合并成一条路径只跟右子节点合并成一条路径以自己为桥梁，跟左、右子节点合并成一条路径需要注意的是，我们在递归求解的时候，第四种情况是不能作为递归的返回值的，因为它不符合我们对递归所期望返回值的定义（因为此时该子节点并不是拥有最大路径和路径的起点（端点）），但它也是一个可能的解，所以我们用一个全局变量记录上面四种值的最大值，递归结束后，该变量就是答案。

再次强调一下，当节点以自己为桥梁连接两边形成一条路径时，根据路径定义，其祖先节点不再可能加入到这条路径中，也就是说这种情况下，它是解的一种可能，但不符合我们递归返回值的定义。

想通上面的逻辑后，代码就呼之欲出了，看看最后的代码，核心的就六七行，却解决了一个Hard问题。

核心代码部分

class Solution {
    static int res = Integer.MIN_VALUE;
    public static int maxPathSum(TreeNode root) {
        dfs(root);
        return res;
    }
​
    // dfs的作用是返回子树一边的最大路径和
    private static int dfs(TreeNode root){
        if(root == null) return 0;
        // 左孩子的最大和
        int left = Math.max(0,dfs(root.left));
        // 右孩子的最大和
        int right = Math.max(0,dfs(root.right));
        // 当前节点的最大和，！！！注意此处需要两边的最大和！！！
        res = Math.max(res,root.val + left + right);
        // 返回以root为根节点的单边的最大路径和
        return Math.max(left,right) + root.val;
    }
}

完整代码

/**
 * TODO
 *
 * @author GGG
 * @since 2024/8/17
 */
public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode() {}
​
    /**
     * 获取
     * @return val
     */
    public int getVal() {
        return val;
    }
​
    /**
     * 设置
     * @param val
     */
    public void setVal(int val) {
        this.val = val;
    }
​
    /**
     * 获取
     * @return left
     */
    public TreeNode getLeft() {
        return left;
    }
​
    /**
     * 设置
     * @param left
     */
    public void setLeft(TreeNode left) {
        this.left = left;
    }
​
    /**
     * 获取
     * @return right
     */
    public TreeNode getRight() {
        return right;
    }
​
    /**
     * 设置
     * @param right
     */
    public void setRight(TreeNode right) {
        this.right = right;
    }
​
    public String toString() {
        return "TreeNode{val = " + val + ", left = " + left + ", right = " + right + "}";
    }
​
    public static int index = 0;
    //测试用例
//    public static final int[] TREE_VALUE = new int[]{1,2,0,0,3,0,0};
    public static final int[] TREE_VALUE = new int[]{-10,9,0,0,20,15,0,0,7,0,0};
​
    //创建一个二叉树
    public static TreeNode createTree(TreeNode node, int i) {
        if (0 == TREE_VALUE[i]) {
            return null;
        } else {
            node.setVal(TREE_VALUE[i]);
        }
​
        TreeNode leftChild = new TreeNode();
        node.left = createTree(leftChild, ++index);
        TreeNode rightChild = new TreeNode();
        node.right = createTree(rightChild, ++index);
​
        return node;
    }
​
    public static void main(String[] args) {
        TreeNode root = new TreeNode();
        root = createTree(root, index);
        System.out.println(root);
        System.out.println(Solution.maxPathSum(root));
    }
}
​
class Solution {
    static int res = Integer.MIN_VALUE;
    public static int maxPathSum(TreeNode root) {
        dfs(root);
        return res;
    }
​
    // dfs的作用是返回子树一边的最大路径和
    private static int dfs(TreeNode root){
        if(root == null) return 0;
        // 左孩子的最大和
        int left = Math.max(0,dfs(root.left));
        // 右孩子的最大和
        int right = Math.max(0,dfs(root.right));
        // 当前节点的最大和，！！！注意此处需要两边的最大和！！！
        res = Math.max(res,root.val + left + right);
        // 返回以root为根节点的单边的最大路径和
        return Math.max(left,right) + root.val;
    }
}