[Swift]LeetCode124. 二叉树中的最大路径和 | Binary Tree Maximum Path Sum

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

Given a non-empty binary tree, find the maximum path sum.

For this problem, a path is defined as any sequence of nodes from some starting node to any node in the tree along the parent-child connections. The path must contain at least one node and does not need to go through the root.

Example 1:

Input: [1,2,3]

       1
      / 
     2   3

Output: 6

Example 2:

Input: [-10,9,20,null,null,15,7]

   -10
   / 
  9  20
    /  
   15   7

Output: 42

---

给定一个非空二叉树，返回其最大路径和。

本题中，路径被定义为一条从树中任意节点出发，达到任意节点的序列。该路径至少包含一个节点，且不一定经过根节点。

示例 1:

输入: [1,2,3]

       1
      / 
     2   3

输出: 6

示例 2:

输入: [-10,9,20,null,null,15,7]

   -10
   / 
  9  20
    /  
   15   7

输出: 42

---

64ms

/**
 * 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 maxPathSum(_ root: TreeNode?) -> Int {
        var result = Int.min
        
        DFS(root, &result)
        
        return result
    }
    
    private func DFS(_ root: TreeNode?, _ result: inout Int) -> Int {
        guard let root = root else {
            return 0
        }
        
        let left = max(0,DFS(root.left, &result))
        let right = max(0,DFS(root.right, &result))
        
        result = max(result, left + right + root.val)
        
        return max(left, right) + root.val
    }
}

---

88ms

/**
 * 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 {
    private var maxValue = Int.min
    
    func maxPathSum(_ root: TreeNode?) -> Int {
        guard let root = root else { return 0 }
        
        maxValue = root.val
        getMaxValue(root)
        return maxValue
    }
    
    
    @discardableResult
    private func getMaxValue(_ root: TreeNode?) -> Int {
        guard let root = root else { return Int.min }
        
        var leftValue = Int.min, rightValue = Int.min
        if let left = root.left {
            leftValue = getMaxValue(left)
        }
        if let right = root.right {
            rightValue = getMaxValue(right)
        }
        
        leftValue = leftValue > 0 ? leftValue : 0
        rightValue = rightValue > 0 ? rightValue : 0
        
        if leftValue + root.val + rightValue > maxValue {
            maxValue = leftValue + root.val + rightValue
        }
        
        return max(leftValue, rightValue) + root.val
    }
}

---

120ms

/**
 * 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 maxPathSum(_ root: TreeNode?) -> Int {
        if root == nil {return 0}
        var tmpMax = root!.val
        maxChildPathSum(root, &tmpMax)
        return tmpMax
    }
    
    /**
     * 计算二叉树子树的最大路径和以及整棵二叉树的最大路径和
     * 子树路径必须以根结点开始，以树中某一结点结束
     * 二叉树的最大路径和的路径，不必以根结点为开始结点
     * @param : root 二叉树根结点
     * @param : tmpMax 暂存整棵二叉树的最路径和的变量的地址
     * @return : 子树的最大路径和
     */ 
    func maxChildPathSum(_ root: TreeNode?,_ tmpMax: inout Int) ->Int
    {
        if root == nil {return 0}
        /* 计算左右子树的最大路径和 */
        var leftMax:Int = maxChildPathSum(root!.left, &tmpMax)
        var rightMax:Int = maxChildPathSum(root!.right, &tmpMax);
         /* 尝试更新整棵二叉树的最大路径和 */ 
        var tmp:Int = root!.val
        if leftMax > 0 {tmp += leftMax}
        if rightMax > 0 {tmp += rightMax}
        if tmp > tmpMax {tmpMax = tmp}
        /* 计算并返回子树的最大路径和 */
        var maxRoot:Int = max(root!.val, max(root!.val + leftMax, root!.val + rightMax))
        return maxRoot
    }
}  

---

224ms

/**
 * 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 maxPathSum(_ root: TreeNode?) -> Int {
        if root == nil {
            return 0
        }
        let root: TreeNode! = root
        var result = root.val
        let temp = nodeMaxSum(root, &result)
        return result
    }
    
    //路过该节点的最大路径和，不以其为根。
    func nodeMaxSum(_ node: TreeNode?, _ result: inout Int) -> Int {
        if node == nil {
            return Int.min
        }
        let node: TreeNode! = node
        let leftNode = nodeMaxSum(node.left, &result)
        let rightNode = nodeMaxSum(node.right, &result)
        var temp = node.val
        temp += leftNode > 0 ? leftNode : 0
        temp += rightNode > 0 ? rightNode : 0
        //result是以其为根的。
        result = max(result, temp)
        //左右子树中最大的值(比0大)与node.val相加
        return max(max(leftNode, rightNode), 0) + node.val
    }
}