[Swift]LeetCode988. 从叶结点开始的最小字符串 | Smallest String Starting From Leaf

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

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

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

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

Given the root of a binary tree, each node has a value from 0 to 25 representing the letters 'a' to 'z': a value of 0 represents 'a', a value of 1 represents 'b', and so on.

Find the lexicographically smallest string that starts at a leaf of this tree and ends at the root.

(As a reminder, any shorter prefix of a string is lexicographically smaller: for example, "ab" is lexicographically smaller than "aba".  A leaf of a node is a node that has no children.)

 

Example 1:

Input: [0,1,2,3,4,3,4]
Output: "dba"

Example 2:

Input: [25,1,3,1,3,0,2]
Output: "adz"

Example 3:

Input: [2,2,1,null,1,0,null,0]
Output: "abc"

Note:

1. The number of nodes in the given tree will be between 1 and 1000.
2. Each node in the tree will have a value between 0 and 25.

---

给定一颗根结点为 root 的二叉树，书中的每个结点都有一个从 0 到 25 的值，分别代表字母 'a'到 'z'：值 0 代表 'a'，值 1 代表 'b'，依此类推。

找出按字典序最小的字符串，该字符串从这棵树的一个叶结点开始，到根结点结束。

（小贴士：字符串中任何较短的前缀在字典序上都是较小的：例如，在字典序上 "ab" 比 "aba" 要小。叶结点是指没有子结点的结点。）

 

示例 1：

输入：[0,1,2,3,4,3,4]
输出："dba"

示例 2：

输入：[25,1,3,1,3,0,2]
输出："adz"

示例 3：

输入：[2,2,1,null,1,0,null,0]
输出："abc"

 

提示：

1. 给定树的结点数介于 1 和 1000 之间。
2. 树中的每个结点都有一个介于 0 和 25 之间的值。

---

 Runtime: 24 ms

Memory Usage: 3.8 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 {
    var ret:String = "~"
    func smallestFromLeaf(_ root: TreeNode?) -> String {
        dfs(root,"")
        return ret
    }
        
    func dfs(_ cur: TreeNode?,_ s: String)
    {
        var s = s
        if cur == nil {return}
        s = String((97 + cur!.val).ASCII) + s
        if cur?.left == nil && cur?.right == nil
        {
            if s < ret {ret = s}
        }
        dfs(cur?.left, s)
        dfs(cur?.right, s)
    }
}
    
//Int扩展方法  
extension Int
{
    //属性：ASCII值(定义大写为字符值)
    var ASCII:Character 
    {
        get {return Character(UnicodeScalar(self)!)}
    }
}

---

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 smallestFromLeaf(_ root: TreeNode?) -> String {
    guard let root = root else {
        return ""
    }
    
    let left = smallestFromLeaf(root.left)
    let right = smallestFromLeaf(root.right)
        
        if left == "" {
        return right + convertIntToChar(val: root.val)
    }
    
    if right == "" {
        return left + convertIntToChar(val: root.val)
    }
    
    return min(left + convertIntToChar(val: root.val), right + convertIntToChar(val: root.val))
}

func convertIntToChar(val: Int) -> String {
    return ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"][val]
  }
}

---

28ms

/**
 * 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 smallestFromLeaf(_ root: TreeNode?) -> String {
        var dict: [Int: String] = [0: "a", 1: "b", 2: "c", 3: "d", 4: "e", 5: "f", 6: "g", 7: "h", 8: "i", 9: "j", 10: "k", 11: "l", 12: "m", 13: "n", 14: "o", 15: "p", 16: "q", 17: "r", 18: "s", 19: "t", 20: "u", 21: "v", 22: "w", 23: "x", 24: "y", 25: "z", ]
        var lists: [String] = []
        var maxDepth = 0
        
        if root?.left == nil && root?.right == nil {
            return String(dict[root?.val ?? 0] ?? "")
        }
        
        func search(_ node: TreeNode?, str: String) {
            guard let node = node else {
                return
            }
            
            var str = str

            str = "\(dict[node.val] ?? "")\(str)"

            if node.left == nil && node.right == nil && str.count > 1 {
                lists.append(str)
            }
            
            search(node.left, str: str)
            search(node.right, str: str)
        }
        
        search(root, str: "")
        
        return lists.sorted().first ?? ""
    }
}

---

32ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public var parent: TreeNode?   
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *         self.parent = nil
 *     }
 * }
 */
class Solution {
    
    func smallestFromLeaf(_ root: TreeNode?) -> String {
        var ans = [String]()
        smallestFromLeaf(root, "", &ans)
        ans.sort()
        return ans.count > 0 ? ans.first! : ""
    }
    
    func smallestFromLeaf(_ root: TreeNode?, _ str: String, _ ans: inout [String]) {
        guard let node = root else {
            return
        }
        var str = str
        str += String(Unicode.Scalar(97 + node.val)!)
        if node.left == nil && node.right == nil {
            var rs = String(str.reversed())
            ans.append(rs)
        }
        
        if let left = node.left {
            smallestFromLeaf(left, str, &ans)
        }
        
        if let right = node.right {
            smallestFromLeaf(right, str, &ans)
        }
    }
}

---

40ms

class Solution {
    func smallestFromLeaf(_ root: TreeNode?) -> String {
        var s = ""
        if root == nil {
            return ""
        }
        var q = [TreeNode]()
        q.append(root!)
        var strs = [String]()
        var m = [Int:Character]()
        for n in 0 ... 25 {
            m[n] =
            Character(Unicode.Scalar(n + Int("a".first!.unicodeScalars.first!.value))!)
        }
        strs.append("\(m[root!.val]!)")
        var alStr = [String]()
        while q.count > 0 {
            var tq = [TreeNode]()
            var ts = [String]()
            while q.count > 0 {
                if let nd = q.popLast(), let s = strs.popLast() {
                    var fl = false
                    var fr = false
                    if let nl = nd.left {
                        tq.append(nl)
                        ts.append(s + "\(m[nl.val]!)") 
                    } else {
                        fl = true
                    }
                    if let nr = nd.right {
                        tq.append(nr)
                        ts.append(s + "\(m[nr.val]!)") 
                    } else {
                        fr = true
                    }
                    if fl && fr {
                        alStr.append(String(s.reversed()))
                    } else if fl || fr {
                        //alStr.append(String(s.reversed()))
                    }
                }
            }
            strs = ts
            q = tq
        }
        alStr.sort()
        return alStr[0]
    }
}