[Swift]LeetCode1080. 根到叶路径上的不足节点 | Insufficient Nodes in Root to Leaf Paths

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

Given the root of a binary tree, consider all root to leaf paths: paths from the root to any leaf.  (A leaf is a node with no children.)

A node is insufficient if every such root to leaf path intersecting this node has sum strictly less than limit.

Delete all insufficient nodes simultaneously, and return the root of the resulting binary tree.

Example 1:

Input: root = [1,2,3,4,-99,-99,7,8,9,-99,-99,12,13,-99,14], limit = 1

Output: [1,2,3,4,null,null,7,8,9,null,14]

Example 2:

Input: root = [5,4,8,11,null,17,4,7,1,null,null,5,3], limit = 22

Output: [5,4,8,11,null,17,4,7,null,null,null,5] 

Note:

1. The given tree will have between 1 and 5000 nodes.
2. -10^5 <= node.val <= 10^5
3. -10^9 <= limit <= 10^9

---

给定二叉树的根 root，考虑所有从根到叶的路径：从根到任何叶的路径。 （叶节点是没有子节点的节点。）

如果交于节点 node 的每个根到叶路径的总和严格小于限制 limit，则该节点为不足节点。

同时删除所有不足节点，并返回生成的二叉树的根。 

示例 1：

输入：root = [1,2,3,4,-99,-99,7,8,9,-99,-99,12,13,-99,14], limit = 1

输出：[1,2,3,4,null,null,7,8,9,null,14]

示例 2：

输入：root = [5,4,8,11,null,17,4,7,1,null,null,5,3], limit = 22

输出：[5,4,8,11,null,17,4,7,null,null,null,5]

示例 3：

输入：root = [5,-6,-6], limit = 0
输出：[] 

提示：

1. 给定的树有 1 到 5000 个节点
2. -10^5 <= node.val <= 10^5
3. -10^9 <= limit <= 10^9

---

128ms

/**
 * 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 sufficientSubset(_ root: TreeNode?, _ limit: Int) -> TreeNode? {
        var newRoot = root
        let sufficient = isSufficientSubset(&newRoot, limit, 0)
        if !sufficient{
            return nil
        }
        
        return newRoot
    }
    
    func isSufficientSubset(_ root:inout TreeNode?, _ limit: Int,_ currentSum:Int) -> Bool{
        guard let root = root else{
            return currentSum >= limit
        }
        
        let leftSuff = isSufficientSubset(&root.left, limit, currentSum + root.val)
        let rightSuff = isSufficientSubset(&root.right, limit, currentSum + root.val)
        if !leftSuff {
            root.left = nil
        }
        
        if !rightSuff {
            root.right = nil
        }
        
        return leftSuff || rightSuff
    }
}

---

132ms

/**
 * 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 sufficientSubset(_ root: TreeNode?, _ limit: Int) -> TreeNode? {        
        guard let root = root else { return nil }
        if root.left === root.right {
            return root.val < limit ? nil : root
        }
        if root.left != nil {
            root.left = sufficientSubset(root.left, limit - root.val)
        }
        if root.right != nil {
            root.right = sufficientSubset(root.right, limit - root.val)
        }
        return root.left === root.right ? nil : root
    }
}

---

Runtime: 152 ms

Memory Usage: 21.4 MB

class Solution {
    func sufficientSubset(_ root: TreeNode?, _ limit: Int) -> TreeNode? {
        let res:Pair = helper(root, 0, limit)
        return res.node
    }
    
    func helper(_ root: TreeNode?,_ cur:Int, _ limit: Int) -> Pair
    {
        var left:Pair? = nil
        var right:Pair? = nil
        
        if root != nil && root?.left == nil && root?.right == nil
        {
            if  cur + root!.val < limit
            {
                return Pair(nil, root!.val)
            }
            else
            {
                return Pair(root, root!.val)
            }
        }
        
        var max_val = Int.min
        if root?.left != nil
        {
            left = helper(root?.left, cur + root!.val, limit)
            max_val = max(left!.max_val, max_val)
        }
        
        if root?.right != nil
        {
            right = helper(root?.right, cur + root!.val, limit)
            max_val = max(right!.max_val, max_val)
        }
        
        if left != nil && left?.node == nil
        {
            root?.left = nil
        }
        if right != nil && right?.node == nil
        {
            root?.right = nil
        }
        
        if (max_val + root!.val + cur < limit)
        {
            return Pair(nil, max_val + root!.val);
        }
        else
        {
            return Pair(root, max_val + root!.val)
        }
    }
}

class Pair
{
    var node:TreeNode?
    var max_val:Int
    
    init(_ n:TreeNode?,_ v:Int)
    {
        self.node = n
        self.max_val = v
    }
}