Binary Tree Maximum Path Sum

题目

Given a binary tree, find the maximum path sum.

The path may start and end at any node in the tree.

For example:
Given the below binary tree,

       1
      / \
     2   3
Return 6.

思路

用递归的思想，假设一个节点的左、右子树的最大值分别是maxL、maxR（并不一定包含左右子树的根节点），

包含左右子树根节点的当前和分别是 curL、curR，

接下来，我们需要比较，根节点的值 val 与 val+max(curL,curR) ，以及 val+curL+curR中的最大值，作为新的cur，将这个cur与maxL和maxR比较

得到max。

代码

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int maxPathSum(TreeNode *root) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        int max = INT_MIN;
        int cur = 0;
        maxTmpSum(root, cur, max);
        return max;
        
    }
    
    void maxTmpSum(TreeNode *root, int &curSum, int &maxSum)
    {
        if(root==NULL)
        {
            curSum = 0;
            return ;
        }
        int leftSum = 0;
        int rightSum = 0;
        maxTmpSum(root->left, leftSum, maxSum);
        maxTmpSum(root->right, rightSum, maxSum);
        curSum =  max(root->val,root->val+max(leftSum,rightSum));
        maxSum = max(maxSum, max(curSum,root->val+leftSum+rightSum));        
    }
    
};

最新

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */

/*
可以利用“最大连续子序列和”问题的思路。
如果说Array只有一个方向的话，那么Binary Tree其实只是左、右两个方向而已，我们需要比较两个方向上的值。
不过，Array可以从头到尾遍历，那么Binary Tree怎么办呢?
我们可以采用Binary Tree最常用的dfs来进行遍历。
先算出左右子树的结果L和R，如果L大于0，那么对后续结果是有利的，我们加上L，如果R大于0，对后续结果也是有利的，继续加上R。
*/

public class Solution {
    private int maxSum;
    public int maxPathSum(TreeNode root) {
        if(root == null){
            return Integer.MAX_VALUE;
        }
        maxSum = root.val;
        dfsPathSum(root);
        return maxSum;
    }
    
    private int dfsPathSum(TreeNode root){
        if(root == null){
            return 0;
        }
        int left = dfsPathSum(root.left);
        int right = dfsPathSum(root.right);
        int cur = root.val;
        if(left > 0){
            cur += left;
        }
        if(right > 0){
            cur += right;
        }
        maxSum = Math.max(cur, maxSum);
        return Math.max(left, right) > 0 ? root.val+Math.max(left, right) : root.val;
    }
    
}