LeetCode //C - 1026. Maximum Difference Between Node and Ancestor

1026. Maximum Difference Between Node and Ancestor

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

A node a is an ancestor of b if either: any child of a is equal to b or any child of a is an ancestor of b.

Example 1:

Input: root = [8,3,10,1,6,null,14,null,null,4,7,13]
Output: 7
Explanation: 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.

Example 2:

Input: root = [1,null,2,null,0,3]
Output: 3

Constraints:

The number of nodes in the tree is in the range [2, 5000].
0 < = N o d e . v a l < = 10 5 0 <= Node.val <= 10^5 0<=Node.val<=105

From: LeetCode

Link: 1026. Maximum Difference Between Node and Ancestor

Solution:

Ideas:

For each node, keep track of:

the minimum value seen on the path from the root to this node
the maximum value seen on the path from the root to this node

Then the maximum ancestor difference on that path is:

curMax - curMin

So during DFS:

update curMin and curMax with the current node value
continue to left and right children
when reaching NULL, return the difference for that path

Code:

c 复制代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

static int max(int a, int b) {
    return a > b ? a : b;
}

static int min(int a, int b) {
    return a < b ? a : b;
}

static int dfs(struct TreeNode* node, int curMin, int curMax) {
    if (node == NULL) {
        return curMax - curMin;
    }

    curMin = min(curMin, node->val);
    curMax = max(curMax, node->val);

    int leftAns = dfs(node->left, curMin, curMax);
    int rightAns = dfs(node->right, curMin, curMax);

    return max(leftAns, rightAns);
}

int maxAncestorDiff(struct TreeNode* root) {
    return dfs(root, root->val, root->val);
}