[Swift]LeetCode865. 具有所有最深结点的最小子树 | Smallest Subtree with all the Deepest Nodes

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

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

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

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

Given a binary tree rooted at root, the depth of each node is the shortest distance to the root.

A node is deepest if it has the largest depth possible among any node in the entire tree.

The subtree of a node is that node, plus the set of all descendants of that node.

Return the node with the largest depth such that it contains all the deepest nodes in its subtree. 

Example 1:Input: [3,5,1,6,2,0,8,null,null,7,4]

Output: [2,7,4]
Explanation:



We return the node with value 2, colored in yellow in the diagram.
The nodes colored in blue are the deepest nodes of the tree.
The input "[3, 5, 1, 6, 2, 0, 8, null, null, 7, 4]" is a serialization of the given tree.
The output "[2, 7, 4]" is a serialization of the subtree rooted at the node with value 2.
Both the input and output have TreeNode type. 

Note:

• The number of nodes in the tree will be between 1 and 500.
• The values of each node are unique.

---

给定一个根为 root 的二叉树，每个结点的深度是它到根的最短距离。

如果一个结点在整个树的任意结点之间具有最大的深度，则该结点是最深的。

一个结点的子树是该结点加上它的所有后代的集合。

返回能满足“以该结点为根的子树中包含所有最深的结点”这一条件的具有最大深度的结点。 

示例：

输入：[3,5,1,6,2,0,8,null,null,7,4]
输出：[2,7,4]
解释：

我们返回值为 2 的结点，在图中用黄色标记。
在图中用蓝色标记的是树的最深的结点。
输入 "[3, 5, 1, 6, 2, 0, 8, null, null, 7, 4]" 是对给定的树的序列化表述。
输出 "[2, 7, 4]" 是对根结点的值为 2 的子树的序列化表述。
输入和输出都具有 TreeNode 类型。 

提示：

• 树中结点的数量介于 1 和 500 之间。
• 每个结点的值都是独一无二的。

---

Runtime: 16 ms

Memory Usage: 19 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 subtreeWithAllDeepest(_ root: TreeNode?) -> TreeNode? {
        return deep(root).1
    }

    func deep(_ root: TreeNode?) -> (Int,TreeNode?)
    {
        if root == nil {return (0, nil)}
        var l:(Int,TreeNode?) = deep(root?.left)
        var r:(Int,TreeNode?) = deep(root?.right)
        var d1:Int = l.0
        var d2:Int = r.0
         return (max(d1, d2) + 1, d1 == d2 ? root : d1 > d2 ? l.1 : r.1);
    }
}

---

16ms

/**
 * 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 subtreeWithAllDeepest(_ root: TreeNode?) -> TreeNode? {
        let (node, _) = helper(root, 0)
        return node
    }
    
    private func helper(_ root: TreeNode?, _ level: Int) -> (TreeNode?, Int) {
        guard root != nil else {
            return (root, level)
        }
        let (leftNode, leftLevel) = helper(root?.left, level + 1)
        let (rightNode, rightLevel) = helper(root?.right, level + 1)
        if leftLevel == rightLevel {
            return (root, leftLevel)
        } else if leftLevel > rightLevel {
            return (leftNode, leftLevel)
        } else {
            return (rightNode, rightLevel)
        }
    }
}

---

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 subtreeWithAllDeepest(_ root: TreeNode?) -> TreeNode? {
        var paths = [[TreeNode]]()
        var soFar = [TreeNode]()
        var max = 0
        getAllLongestPaths(root, &paths, &soFar, &max, 0)
        if paths.count == 0 { return nil }
        var result: TreeNode? = nil
        for i in paths[0].indices {
            var temp = paths[0][i]
            var foundDiff = false
            for j in 1..<paths.count {
                if paths[j][i].val != temp.val {
                    foundDiff = true
                    break
                }
            }
            if foundDiff { break }
            result = temp
        }
        return result
    }
    
    func getAllLongestPaths(_ root: TreeNode?, _ path: inout [[TreeNode]], _ soFar: inout [TreeNode], 
                            _ maxLevel: inout Int, _ level: Int) {
        if (root == nil) { return }
        
        if root!.left == nil && root!.right == nil {
            if level >= maxLevel {
                if level > maxLevel {
                    maxLevel = level
                    path.removeAll()
                }
                soFar.append(root!)
                path.append(soFar)
                soFar.removeLast()
            }
            return
        }
        maxLevel = max(maxLevel, level)
        soFar.append(root!)
        getAllLongestPaths(root!.left, &path, &soFar, &maxLevel, level + 1)
        getAllLongestPaths(root!.right, &path, &soFar, &maxLevel, level + 1)
        soFar.removeLast()
    }
}

---

24ms

/**
 * 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 subtreeWithAllDeepest(_ root: TreeNode?) -> TreeNode? {
        return subtree(root).node 
    }
    
    func subtree(_ root: TreeNode?) -> (node: TreeNode?, depth: Int) {
        guard let root = root else {
            return (node: nil, depth: 0)
        }
        
        let left = subtree(root.left)
        let right = subtree(root.right)
        
        if left.depth > right.depth {
            return (node: left.node, depth: left.depth + 1) 
        }
        
        if left.depth < right.depth {
            return (node: right.node, depth: right.depth + 1) 
        }
        
        return (node: root, depth: left.depth + 1) 
    }
}