<p>Given the <code>root</code> of a binary tree, find the maximum value <code>v</code> for which there exist <strong>different</strong> nodes <code>a</code> and <code>b</code> where <code>v = |a.val - b.val|</code> and <code>a</code> is an ancestor of <code>b</code>.</p>

<p>A node <code>a</code> is an ancestor of <code>b</code> if either: any child of <code>a</code> is equal to <code>b</code>&nbsp;or any child of <code>a</code> is an ancestor of <code>b</code>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2020/11/09/tmp-tree.jpg" style="width: 400px; height: 390px;" />
<pre>
<strong>Input:</strong> root = [8,3,10,1,6,null,14,null,null,4,7,13]
<strong>Output:</strong> 7
<strong>Explanation: </strong>We have various ancestor-node differences, some of which are given below :
|8 - 3| = 5
|3 - 7| = 4
|8 - 1| = 7
|10 - 13| = 3
Among all possible differences, the maximum value of 7 is obtained by |8 - 1| = 7.</pre>

<p><strong class="example">Example 2:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2020/11/09/tmp-tree-1.jpg" style="width: 250px; height: 349px;" />
<pre>
<strong>Input:</strong> root = [1,null,2,null,0,3]
<strong>Output:</strong> 3
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li>The number of nodes in the tree is in the range <code>[2, 5000]</code>.</li>
	<li><code>0 &lt;= Node.val &lt;= 10<sup>5</sup></code></li>
</ul>

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def maxAncestorDiff(self, root: Optional[TreeNode]) -> int:
        # if node is None => 0
        # res = 0
        # dsf(node, minVal, maxVal):
            # if node is None -> 
            
            # if node.val < minVal:
                # minVal = node.val
            # elif node.val > maxVal:
                # maxVal = node.val
            
            # res = max(res, abs(maxVal - minVal))
            # dfs(node.left, minVal, maxVal)
            # dfs(node.right, minVal, maxVal)
        
        # dfs(root, root.val, root.val)
        # return res

        if not root:
            return 0
        
        self.res = 0

        def dfs(node, minVal, maxVal):
            if not node:
                return
            
            if node.val < minVal:
                minVal = node.val
            elif node.val > maxVal:
                maxVal = node.val
            
            self.res = max(self.res, abs(maxVal - minVal))
            dfs(node.left, minVal, maxVal)
            dfs(node.right, minVal, maxVal)
        
        dfs(root, root.val, root.val)
        return self.res

        #### Editorial Solution (DFS)

        # if not root:
        #     return 0
        # # record the required maximum difference
        # self.result = 0

        # def helper(node, cur_max, cur_min):
        #     if not node:
        #         return
        #     # update `result`
        #     self.result = max(self.result, abs(cur_max-node.val),
        #                       abs(cur_min-node.val))
        #     # update the max and min
        #     cur_max = max(cur_max, node.val)
        #     cur_min = min(cur_min, node.val)
        #     helper(node.left, cur_max, cur_min)
        #     helper(node.right, cur_max, cur_min)

        # helper(root, root.val, root.val)
        # return self.result
17900