2个叶子节点之间的最大路径和(GeeksForGeeks)

Question

Given a binary tree in which each node element contains a number. Find the maximum possible sum from one leaf node to another.

Example 1:

Input :      
           3                               
         /    \                          
       4       5                     
      /  \      
    -10   4                          

Output: 16

Explanation : Maximum Sum lies between leaf node 4 and 5. 4 + 4 + 3 + 5 = 16.

Example 2:

Input :    
            -15                               
         /      \                          
        5         6                      
      /  \       / \
    -8    1     3   9
   /  \              \
  2   -3              0
                     / \
                    4  -1
                       /
                     10  

Output :  27

Explanation: The maximum possible sum from one leaf node to another is (3 + 6 + 9 + 0 + -1 + 10 = 27)

This is the solution:

'''
# Node Class:
class Node:
    def _init_(self,val):
        self.data = val
        self.left = None
        self.right = None
        '''
res = -999999999
def maxPathSumUtil(root):
    global res
    if root is None:
        return 0
    
    if root.left is None and root.right is None:
        return root.data

    ls=maxPathSumUtil(root.left)
    rs=maxPathSumUtil(root.right)
    
    if root.left and root.right:
        res=max(res,ls+rs+root.data)
        return max(ls+root.data,rs+root.data) #Line: Problem
    if root.left is None:
        return rs+root.data
    else:
        return ls+root.data


def maxPathSum(root):
    global res
    res = -999999999
    maxPathSumUtil(root)
    return res

Can anyone tell me why do we use return max(ls+root.data,rs+root.data) . And if we do use return max(ls+root.data,rs+root.data) for checking the maximum value then why do we use res=max(res,ls+rs+root.data) and not just res = max(ls+root.data,rs+root.data) .

EDIT:

For example:

Let's take this tree for example:

             10
           /   \
         8      2
       /  \
     3     5

In this, after recursive calls, ls becomes 3 and rs becomes 5. res becomes ls+rs+root.data which is 3+5+8 = 16. Then return max(ls+root.data,rs+root.data) which is max(11,13) = 13. Now after this according to me the function should just return 13 but that does not happen. Even though return is not a recursive statement. How is the control flow of the code happening?

Answer 1

There are two things that are measured in parallel during execution:

• ls+rs+root.data is the max path in the tree rooted by root , between two of the leaves below it. So it is (the value) of a leaf -to-leaf path
• The function return value is the maximum path from root to any of the leaves below it. So it is (the value) of a root -to-leaf path

These are two different concepts and should not be mixed up.

Both ls and rs are function return values: ls represents the maximum path from root.left to a leaf. And in the same way rs represents the maximum path from root.right to a leaf.

ls+rs+root.data on the other hand, represents a path from leaf to leaf passing through root .

res should be updated if that latter expression is greater than res , hence the max() .

But the function's return value should not represent a leaf-to-leaf path, but a root-to-leaf path. So that is why we have:

return max(ls+root.data,rs+root.data)

This tells the caller what the maximum root-to-leaf path is, not what the maximum leaf-to-leaf path is. The latter is used for determining res , not the function's return value.

I hope this clarifies the distinction between these two concepts and the roles they play in the algorithm.

The example

You presented this tree as example:

         10
       /   \
     8      2
   /  \
 3     5

Indeed, when the function is called for the node 8, it:

• sets res to 16 (the max path between two leaves below the node)
• returns 13 (the max path from the node to one of its leaves)

You then ask:

Now after this according to me the function should just return 13 but that does not happen.

But it does happen like that. You should however not forget that this is the return value of maxPathSumUtil , not of maxPathSum . Also, this is not the top-level call of maxPathSumUtil . The value 13 is returned to another execution context of maxPathSumUtil , where root is the node 10. Then -- after another recursive call is made (with root equal to node 2), this top-level execution of the function maxPathSumUtil will:

• set res to 25 (the max path between two leaves below the node 10)
• return 23 (the max path from the node 10 to one of its leaves)

This toplevel call was made from within maxPathSum , which ignores the value returned by maxPathSumUntil . It only takes the value of res (25), and returns that :

maxPathSumUtil(root)  # notice that return value is ignored.
return res

Answer 2

At each node, we have to check whether that node's left and right child resulted in max path. But when we return, we need to return either the left or right path depending upon whichever is max. Let's take this tree for example:

         10
       /   \
     8      2
   /  \
 3     5

In this, after recursive calls, ls becomes 3 and rs becomes 5. res becomes ls+rs+root.data which is 3+5+8 = 16. So res(result) will be updated to 16, and return will be max(11,13) which is 13. Now this 13 value will be used by node 10 as ls(left value).