Binary Tree Maximum Path Sum

Fair Binary
Tree Maximum Path Sum
Show Result My Submissions

22%

Accepted

Given a binary tree, find the maximum path sum.

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

Given the below binary tree,

1
/ \
2   3

Key:

1. Divide & Conquer

2. Save two information: maxPath & singlePath

3. maxPath: similar to a global variable. We store in it the max path sum found so far. Not necessarily include the current root node.

    singlePath: store in it the max path sum for a single path, either include the root(left.singlePath + root.val or right.singlePath + root.val) or not include the root (0).

4. Initial condition: if the current node is a leaf, singlePath should be 0, because singlePath doesn't have to include the current node. MaxPath should be Integer.MAX_VALUE.

/**
* Definition of TreeNode:
* public class TreeNode {
* public int val;
* public TreeNode left, right;
* public TreeNode(int val) {
* this.val = val;
* this.left = this.right = null;
* }
* }
*/
public class Solution {
/**
* @param root: The root of binary tree.
* @return: An integer.
*/
public int maxPathSum(TreeNode root) {
if (root == null) {
return 0;
}
return helper(root).maxPath;
}

ReturnType helper(TreeNode root) {
if (root == null) {
return new ReturnType(Integer.MIN_VALUE, 0);
}
ReturnType left = helper(root.left);
ReturnType right = helper(root.right);
int singlePath = Math.max(left.singlePath + root.val,
right.singlePath + root.val);
singlePath = Math.max(0, singlePath);

int maxPath = Math.max(left.maxPath, right.maxPath);
maxPath = Math.max(maxPath, left.singlePath + root.val + right.singlePath);
return new ReturnType(maxPath, singlePath);
}

class ReturnType {
int maxPath;
int singlePath;

public ReturnType(int maxPath, int singlePath) {
this.maxPath = maxPath;
this.singlePath = singlePath;
}
}
}