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

思路：

我们需要求的是二叉树最大路径和，“路径”，则必须是包含根节点才算作一条路径，若只有左右节点，则无法连接，不能构成路径。而单独的左节点，单独右节点或者单独的一个根节点都可以算作一条路径，因为他们都可以独立成一个根节点。

当要求得整棵树的最大和时，应该先递归地求出左子树，右子树分别对应的路径最大和，这样整棵树的最大和就是比较左子树最大和+根节点和右子树最大和加根节点的值与不加根节点的值的较大者。并且我们在递归的过程中对用全局变量max记录过程中的最大值。

实现：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    int max=Integer.MIN_VALUE;
    public int maxPathSum(TreeNode root) {
        if(root==null){
            return 0;
        }
        fun(root);
        return max;        
    }
    private int fun(TreeNode root){
        if(root==null) return 0;
        int left=Math.max(0,fun(root.left));
        int right=Math.max(0,fun(root.right));
        max=Math.max(max,left+right+root.val);
        return Math.max(left+root.val,right+root.val);
    }
}

 

实现2：参加九章算法

我们要求得二叉树的最大和可能单独存在于左子树或右子树，也可能是左子树+根节点，或右子树+根节点，或者左右子树+根节点。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class ResultType{
    int root2Any,any2Any;
    ResultType(int root2Any,int any2Any){
        this.root2Any=root2Any;
        this.any2Any=any2Any;
    }
}
class Solution {
    public int maxPathSum(TreeNode root) {
        ResultType rt=fun(root);
        return rt.any2Any;        
    }
    private ResultType fun(TreeNode root){
        if(root==null){
            return new ResultType(Integer.MIN_VALUE,Integer.MIN_VALUE);
        }
        //divide
        ResultType left=fun(root.left);
        ResultType right=fun(root.right);
        //Conquer
        int root2Any=Math.max(0,Math.max(left.root2Any,right.root2Any))+root.val;
        int any2Any=Math.max(left.any2Any,right.any2Any);
        any2Any=Math.max(any2Any,Math.max(0,left.root2Any)+Math.max(0,right.root2Any)+root.val);
        return new ResultType(root2Any,any2Any);       
    }
}