[leetcode]124. Binary Tree Maximum Path Sum二叉树最大路径和

Given a non-empty binary tree, find the maximum path sum.

For this problem, a path is defined as any sequence of nodes from some starting node to any node in the tree along the parent-child connections. The path must contain at least one node and does not need to go through the root.

Example 1:

Input: [1,2,3]

       1
      / \
     2   3

Output: 6

Example 2:

Input: [-10,9,20,null,null,15,7]

   -10
   / \
  9  20
    /  \
   15   7

Output: 42

 

思路

dfs:

            2

         /       \

        1         -3

maxPath:  1 + 2 + 0 

1. use maxPath to update result from all paths which is max path sum 

2. divide a path into 3 parts:

a. left path: from root to left side down to 0 or more steps

b. right path: from root to right side down to 0 or more steps 

c. cur root itself 

3. maxPath = c + (a>0 ? a: 0 ) + (b > 0 ? b:0)

 

这是一道关于BST和recursion的经典题，需要掌握

最naive的想法是找到所有BST的path，返回max

发现， 任意一条path都有一个顶点（位置最高点）

我们用这个顶点来分解所有path

这样，以任意一个点为顶点的path就分解为

a. max_sum (左边path)

b. max_sum (右边path)

c. 顶点自己的value

进一步，

a + b + c 组成的人字形path的max path sum

     2
    /  \
   1    -3

dfs的return value :  2(顶点自己的value必须加上，无论正负) +  1 （正数贡献自己） + 0 (-3为负数不做贡献就是及时止损了)  = 3 

 

跟 [leetcode]543. Diameter of Binary Tree二叉树直径 的思路基本一致。

 

代码

class Solution {
    public int maxPathSum(TreeNode root) {
        // corner case 
        if(root == null){return 0;}
         /* 要么用个global variable放在class下，要么用长度为1的一维数组来存。
            maxSum的value，可正可负，初始化为Integer.MIN_VALUE。
        */
        int[] maxPath = new int[]{Integer.MIN_VALUE};
        dfs(root, maxPath);
        return maxPath[0];
    }
    // 递归求以root为顶点所有直上直下的path中，path sum最大的一条值。没有U-turn的
    private int dfs(TreeNode root, int[]maxPath){
        // left > 0 benefit sum, add to sum; left < 0 will worsen sum, default 0 
        int left = root.left != null ? Math.max(dfs(root.left, maxPath), 0) : 0;
        int right = root.right != null ? Math.max(dfs(root.right, maxPath), 0) : 0;
        int cur = root.val + left + right;
        maxPath[0] = Math.max(maxPath[0], cur);
        return root.val  + Math.max(left, right);
    }   
}