【LeetCode OJ】Binary Tree Maximum Path Sum

Problem Link:

http://oj.leetcode.com/problems/binary-tree-maximum-path-sum/

For any path P in a binary tree, there must exists a node N in P such that N is the ancestor node of all other nodes in P. We call such N as the root of P, or P roots at N.

Then we know that any maximum sum path must root at some node in the tree. Therefore, the naive method to solve this problem is to check all paths root at each node in the tree, and return the maximum path sum.

We can solve this problem efficiently in the help of the function that can find the maximum sum path from the node to any nodes in its sub-tree.

Let P = {N₁, ..., N_n, N, M₁, ..., M_m} be a maximum path rooting at N, where n and m both could be 0. Then {N₁, ..., N_n, N} would be the maximum path from N to any nodes in N's left sub-tree, and {N, M₁, ..., M_m} must be the maximum path from N to any nodes in N's right sub-tree. Therefore, we can traverse the tree in post-order, and for each node N we compute the maximum path rooting at N and update it with a global variable. The recursive algorithm can go as follows.

MAX-PATH-SUM-RECURSIVE(node N):
　　if N is NULL:
　　　　return 0
　　// Compute the maximum path sum of N's children recursively
　　l_max_path_sum = MAX-PATH-SUM-RECURSIVE(N.left)
　　r_max_path_sum = MAX-PATH-SUM-RECURSIVE(N.right)
　　// Compute the maximum path rooting at N
　　my_max_sum = N.val
　　if l_max_path_sum > 0 then 
　　　　my_max_sum += l_max_path_sum
　　if r_max_path_sum > 0 then
　　　　my_max_sum += r_max_path_sum
　　// Compare with the global variable
　　if my_max_sum > CURRENT_MAX_SUM:
　　　　CURRENT_MAX_SUM = my_max_sum
　　// Return the maximum path sum from N to nodes in N's sub-tree
　　return max(N.val, N.val + l_max_path_sum, N.val + r_max_path_sum)

So we call the recursive function from tree root, the function would compute maximum path sum starting from each node. At the same time, we maintian the global CURRENT_MAX_SUM which stores the maximum path sum. When the post-order traversal from the root is done, we return CURRENT_MAX_SUM.

class Solution:
    # @param root, a tree node
    # @return an integer
    def maxPathSum(self, root):
        """
        For any max path P of the tree, there must exist a node N in P,
        such that N is the ancestor node of all other nodes in P.
        Let P = {N_1, ..., N_n, N, M_1, ..., M_m}, n and m could be 0.
        Then we know that {N_1, ..., N_n, N} is the maximum path from N to nodes in its left sub-tree,
         and {N, M_1, ..., M_m} is the maximum path from N to nodes in its right sub-tree.
        Therefore, we can run the recursive function that finds the maximum path from N to nodes in its sub-tree,
        and use a global variable to store the sum of max path P for each N.

        @param root: a binary tree node
        @return: the maximum path sum of the tree
        """
        self.res = 0
        if root:
            self.res = root.val
            self.maxPathSum_recursive(root)
        return self.res

    def maxPathSum_recursive(self, node):
        """
        Find the maximum path sum of all paths from node to any nodes in its sub-tree
        The recursive function works as follows:
            1. If the node is None, return 0
            2. Let L be the maximum sum of node.left
            3. Let R be the maximum sum of node.right
            4. return max(node.val, node.val + L, node.val + R)

        @param node: a binary tree node
        @return: the maximum path sum from node to any node in its sub-tree
        """
        if node is None:
            return 0
        else:
            # Compute the left max path sum
            left_max = self.maxPathSum_recursive(node.left)
            # Compute the left max path sum
            right_max = self.maxPathSum_recursive(node.right)
            # Update the result with the max path sum rooted at node
            max_sum_passing_node = node.val
            if left_max > 0:
                max_sum_passing_node += left_max
            if right_max > 0:
                max_sum_passing_node += right_max
            self.res = max(self.res, max_sum_passing_node)
            # Return the max path sum from this node
            return max(node.val, node.val+left_max, node.val+right_max)