[Swift]LeetCode1026. 节点与其祖先之间的最大差值 | Maximum Difference Between Node and Ancestor

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址： https://www.cnblogs.com/strengthen/p/10704595.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

Given the root of a binary tree, find the maximum value V for which there exists 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: [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.

Note:

1. The number of nodes in the tree is between 2 and 5000.
2. Each node will have value between 0 and 100000.

---

给定二叉树的根节点 root，找出存在于不同节点 A 和 B 之间的最大值 V，其中 V = |A.val - B.val|，且 A 是 B 的祖先。

（如果 A 的任何子节点之一为 B，或者 A 的任何子节点是 B 的祖先，那么我们认为 A 是 B 的祖先）

示例：

输入：[8,3,10,1,6,null,14,null,null,4,7,13]
输出：7
解释： 
我们有大量的节点与其祖先的差值，其中一些如下：
|8 - 3| = 5
|3 - 7| = 4
|8 - 1| = 7
|10 - 13| = 3
在所有可能的差值中，最大值 7 由 |8 - 1| = 7 得出。

提示：

1. 树中的节点数在 2 到 5000 之间。
2. 每个节点的值介于 0 到 100000 之间。

---

20ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    func maxAncestorDiff(_ root: TreeNode?) -> Int {
        return traverse(root, Int.min, Int.max)
    }
    func traverse(_ node: TreeNode?, _ maxVal: Int, _ minVal: Int) -> Int {
        guard let node = node else {
            return abs(maxVal - minVal)
        }
        var maxVal = max(maxVal, node.val)
        var minVal = min(minVal, node.val)
        var maxDiff = maxVal - minVal
        if let left = node.left {
            maxDiff = max(maxDiff, traverse(left, maxVal, minVal))
        }
        if let right = node.right {
            maxDiff = max(maxDiff, traverse(right, maxVal, minVal))
        }
        return maxDiff
    }
}

---

24ms

class Solution {
    // var ret = 0
    func maxAncestorDiff(_ root: TreeNode?) -> Int {
        if root == nil {
            return 0
        }
        
        var maxDiff = 0
        dfs(root!, root!.val, root!.val, &maxDiff)
        return maxDiff
    }
    
    func dfs(_ node: TreeNode, _ minVal: Int, _ maxVal: Int, _ maxDiff: inout Int) {        

        let a = abs(node.val - minVal)
        let b = abs(node.val - maxVal)
        maxDiff = getMax(a, b, maxDiff)
        
        if (node.left != nil && node.right == nil) {
            dfs(node.left!, min(minVal, node.left!.val), max(maxVal, node.left!.val), &maxDiff)
        } else if (node.left == nil && node.right != nil) {
            dfs(node.right!, min(minVal, node.right!.val), max(maxVal, node.right!.val), &maxDiff)
        } else if (node.left != nil && node.right != nil) {
            dfs(node.left!, min(minVal, node.left!.val), max(maxVal, node.left!.val), &maxDiff)
            dfs(node.right!, min(minVal, node.right!.val), max(maxVal, node.right!.val), &maxDiff)
        }
        return
    } 
    
    func getMax(_ a: Int, _ b: Int, _ c: Int) -> Int {
        return getMax(getMax(a,b), c)
    }
    
    func getMax(_ a: Int, _ b: Int) -> Int {
        if (a > b) {
            return a
        } else {
            return b
        }
    }
    
    func dfs(_ node: TreeNode) {        
        if (node.left == nil && node.right == nil) {
            // node is leaf
            node.leftMin = node.val
            node.leftMax = node.val
            node.rightMin = node.val
            node.rightMax = node.val
        }
        if (node.left != nil && node.right == nil) {
            // node has left child, has no right child
            node.rightMin = node.val
            node.rightMax = node.val
            dfs(node.left!)
            node.leftMin = min(node.left!.leftMin, node.left!.rightMin, node.val)
            // print("node", node.val, "has leftMin", node.leftMin)
            node.leftMax = max(node.left!.leftMax, node.left!.rightMax, node.val)
            // print("node", node.val, "has leftMax", node.leftMax)
        }
        else if (node.left == nil && node.right != nil) {
            // node has right child, has no left child
            node.leftMin = node.val
            node.leftMax = node.val
            dfs(node.right!)
            node.rightMin = min(node.right!.leftMin, node.right!.rightMin, node.val)
            // print("node", node.val, "has rightMin", node.rightMin)
            node.rightMax = max(node.right!.leftMax, node.right!.rightMax, node.val)
            // print("node", node.val, "has rightMax", node.rightMax)
        }
        else if (node.left != nil && node.right != nil) {
            dfs(node.left!)
            node.leftMin = min(node.left!.leftMin, node.left!.rightMin, node.val)
            node.leftMax = max(node.left!.leftMax, node.left!.rightMax, node.val)
            
            dfs(node.right!)
            node.rightMin = min(node.right!.leftMin, node.right!.rightMin, node.val)
            node.rightMax = max(node.right!.leftMax, node.right!.rightMax, node.val)
        }
        // print("node", node.val, ": lMin, lMax, rMin, rMax,", node.leftMin, node.leftMax, node.rightMin, node.rightMax)

        return
    }    
}

extension TreeNode {
    private struct Holder {
        static var leftMin = [String : Int]()
        static var leftMax = [String : Int]()
        static var rightMin = [String : Int]()
        static var rightMax = [String : Int]()
    }
    
    var leftMin: Int {
        get {
            let tmpAddress = String(format: "%p", unsafeBitCast(self, to: Int.self))
            return Holder.leftMin[tmpAddress] ?? 0
        }
        set(newValue) {
            let tmpAddress = String(format: "%p", unsafeBitCast(self, to: Int.self))
            Holder.leftMin[tmpAddress] = newValue
        }
    }
    
    var rightMin: Int {
            get {
                let tmpAddress = String(format: "%p", unsafeBitCast(self, to: Int.self))
                return Holder.rightMin[tmpAddress] ?? 0
            }
            set(newValue) {
                let tmpAddress = String(format: "%p", unsafeBitCast(self, to: Int.self))
                Holder.rightMin[tmpAddress] = newValue
            }
        }
        
    var leftMax: Int {
        get {
            let tmpAddress = String(format: "%p", unsafeBitCast(self, to: Int.self))
            return Holder.leftMax[tmpAddress] ?? 0
        }
        set(newValue) {
            let tmpAddress = String(format: "%p", unsafeBitCast(self, to: Int.self))
            Holder.leftMax[tmpAddress] = newValue
        }
    }
    
    var rightMax: Int {
        get {
            let tmpAddress = String(format: "%p", unsafeBitCast(self, to: Int.self))
            return Holder.rightMax[tmpAddress] ?? 0
        }
        set(newValue) {
            let tmpAddress = String(format: "%p", unsafeBitCast(self, to: Int.self))
            Holder.rightMax[tmpAddress] = newValue
        }
    }
}

---

32ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    var result = Int.min
    func maxAncestorDiff(_ root: TreeNode?) -> Int {
        guard let root = root else {
            return 0
        }
        
        dfsHelper(root)
        
        return result
    }
    
    @discardableResult
    fileprivate func dfsHelper(_ root: TreeNode?) -> (Int, Int) {
        guard let root = root else {
            return (Int.max, Int.min)
        }
        
        if root.left == nil && root.right == nil {
            return (root.val, root.val)
        }
        
        let (leftTempMin, leftTempMax) = dfsHelper(root.left)
        let (rightTempMin, rightTempMax) = dfsHelper(root.right)
        
        let currentMin = min(min(leftTempMin, rightTempMin), root.val)
        let currentMax = max(max(root.val, rightTempMax), leftTempMax)
        result = max(max(result, abs(root.val - currentMin)), abs(root.val - currentMax))
        return (currentMin, currentMax)
        
    }
}

---

52ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    func maxAncestorDiff(_ root: TreeNode?) -> Int {
        return diffAndMin(root)?.diff ?? 0
    }

    func diffAndMin(_ root: TreeNode?) -> (diff: Int, min: Int, max: Int)? {
        guard let root = root else { return nil }

        var diffs = [Int](), mins = [root.val], maxs = [root.val]
        if let (lDiff, lMin, lMax) = diffAndMin(root.left) {
            diffs += [lDiff, abs(root.val - lMin), abs(root.val - lMax)]
            mins.append(lMin)
            maxs.append(lMax)
        }
        
        if let (rDiff, rMin, rMax) = diffAndMin(root.right) {
            diffs += [rDiff, abs(root.val - rMin), abs(root.val - rMax)]
            mins.append(rMin)
            maxs.append(rMax)
        }
        
        return (diffs.max() ?? 0, mins.min()!, maxs.max()!)
    }
}

---

Runtime: 416 ms

Memory Usage: 129.4 MB

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    func maxAncestorDiff(_ root: TreeNode?) -> Int {
        var list:[[Int]] = binaryTreePaths(root)
        var res:Int = 0
        for arr in list
        {
            res = max(res,getMaxDifference(arr))
        }
        return res
    }
    
    func getMaxDifference(_ arr:[Int]) -> Int
    {
        var res:Int = 0
        for i in 0..<arr.count
        {
            for j in (i + 1)..<arr.count
            {
                res = max(res,abs(arr[i] - arr[j]))
            }
        }
        return res
    }
    
    //获取所有子树
    func binaryTreePaths(_ root: TreeNode?) -> [[Int]] {
        var list:[[Int]] = [[Int]]()
        recuesive(root,&list,[Int]())
        return list
    }
    
    func recuesive(_ root:TreeNode?,_ list:inout [[Int]],_ arr:[Int])
    {
        if root == nil {return}
        var arrNew:[Int] = arr
        var arrRoot:[Int] = [root!.val]
        if root?.left == nil && root?.right == nil
        {
            arrNew += arrRoot
            list.append(arrNew)
            return
        }
        arrRoot = arrNew + arrRoot
        recuesive(root?.left,&list,arrRoot)
        recuesive(root?.right,&list,arrRoot)
    }
}