悄悄话

import Foundation

// 定义二叉树节点
class TreeNode {
    var val: Int
    var left: TreeNode?
    var right: TreeNode?
    
    init(_ val: Int) {
        self.val = val
        self.left = nil
        self.right = nil
    }
}

class Solution {
    func maxTimeToSpreadMessage(_ root: TreeNode?) -> Int {
        guard let root = root else {
            return 0
        }
        return dfs(root)
    }
    
    private func dfs(_ node: TreeNode?) -> Int {
        guard let node = node else {
            return 0
        }
        
        let leftTime = dfs(node.left)
        let rightTime = dfs(node.right)
        
        return node.val + max(leftTime, rightTime)
    }
    
    func buildTree(_ nodes: [Int?]) -> TreeNode? {
        guard !nodes.isEmpty else {
            return nil
        }
        
        var queue = [TreeNode?]()
        let root = TreeNode(nodes[0]!)
        queue.append(root)
        
        var index = 1
        while index < nodes.count {
            let current = queue.removeFirst()
            
            if let leftValue = nodes[index], leftValue != -1 {
                let leftNode = TreeNode(leftValue)
                current?.left = leftNode
                queue.append(leftNode)
            }
            index += 1
            
            if index < nodes.count, let rightValue = nodes[index], rightValue != -1 {
                let rightNode = TreeNode(rightValue)
                current?.right = rightNode
                queue.append(rightNode)
            }
            index += 1
        }
        
        return root
    }
}

// 示例输入
let input: [Int?] = [0, 9, 20, nil, nil, 15, 7, nil, nil, nil, nil, 3, 2]

let solution = Solution()
if let root = solution.buildTree(input) {
    print("Max time to spread the message: \(solution.maxTimeToSpreadMessage(root))")
}