[Swift]LeetCode720. 词典中最长的单词 | Longest Word in Dictionary

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

Given a list of strings words representing an English Dictionary, find the longest word in words that can be built one character at a time by other words in words. If there is more than one possible answer, return the longest word with the smallest lexicographical order.

If there is no answer, return the empty string.

Example 1:

Input: 
words = ["w","wo","wor","worl", "world"]
Output: "world"
Explanation: 
The word "world" can be built one character at a time by "w", "wo", "wor", and "worl". 

Example 2:

Input: 
words = ["a", "banana", "app", "appl", "ap", "apply", "apple"]
Output: "apple"
Explanation: 
Both "apply" and "apple" can be built from other words in the dictionary. However, "apple" is lexicographically smaller than "apply".

Note:

• All the strings in the input will only contain lowercase letters.
• The length of words will be in the range [1, 1000].
• The length of words[i] will be in the range [1, 30].

---

给出一个字符串数组words组成的一本英语词典。从中找出最长的一个单词，该单词是由words词典中其他单词逐步添加一个字母组成。若其中有多个可行的答案，则返回答案中字典序最小的单词。

若无答案，则返回空字符串。

示例 1:

输入: 
words = ["w","wo","wor","worl", "world"]
输出: "world"
解释: 
单词"world"可由"w", "wo", "wor", 和 "worl"添加一个字母组成。

示例 2:

输入: 
words = ["a", "banana", "app", "appl", "ap", "apply", "apple"]
输出: "apple"
解释: 
"apply"和"apple"都能由词典中的单词组成。但是"apple"得字典序小于"apply"。

注意:

• 所有输入的字符串都只包含小写字母。
• words数组长度范围为[1,1000]。
• words[i]的长度范围为[1,30]。

---

188ms

class Solution {
    func longestWord(_ words: [String]) -> String {
    var result = ""
        let hashSet = Set(words)
        for word in words {
            var valid = true
            if word.count < result.count {
                continue
            }
            if word.count == result.count && word > result {
                continue
            }
            let startIndex = word.startIndex
            for i in 0 ..< word.count - 1 {
                let index = word.index(startIndex, offsetBy: i+1)
                let mySubstring = word[..<index] // Hello
                if !hashSet.contains(String(mySubstring)) {
                    valid = false
                    break
                }
            }
            if valid {
                result = word
            }
        }
        
        return result
    }
}

---

Runtime: 192 ms

Memory Usage: 20.2 MB

class Solution {
    func longestWord(_ words: [String]) -> String {
        var res:String = String()
        var s:Set<String> = Set<String>()
        var words = words.sorted(by:<)
        for word in words
        {
            if word.count == 1 || s.contains(word.subString(0, word.count - 1))
            {
                res = (word.count > res.count) ? word : res
                s.insert(word)
            }
        }
        return res
    }
}

extension String {
    // 截取字符串：指定索引和字符数
    // - begin: 开始截取处索引
    // - count: 截取的字符数量
    func subString(_ begin:Int,_ count:Int) -> String {
        let start = self.index(self.startIndex, offsetBy: max(0, begin))
        let end = self.index(self.startIndex, offsetBy:  min(self.count, begin + count))
        return String(self[start..<end]) 
    }    
}

---

Runtime: 200 ms

Memory Usage: 20.5 MB

class Solution {
    func longestWord(_ words: [String]) -> String {
        let sortedWords = words.sorted()
        var set = Set([""])
        var res = ""

        for word in sortedWords {
            if set.contains(String(word.prefix(word.count-1))) {
                set.insert(word)
                if word.count > res.count {
                    res = word
                }
            }
        }
        return res
    }
}

---

208ms

class Solution {    
    enum Contains {        
        case unknown
        case valid
        case invalid        
    }    
    
    func longestWord(_ words: [String]) -> String {

        var max = 0
        var maxString = ""
        var hash = [String: Contains]()
        
        for eachWord in words {            
            if eachWord.count == 1 {
                hash[eachWord] = .valid
                max = 1
                maxString = eachWord
                continue
            }            
            hash[eachWord] = .unknown
        }
        for eachWord in words {
            
            if eachWord.count >= max && isValid(eachWord, in: &hash) { 
                if eachWord.count == max && eachWord > maxString {
                    continue
                }                  
                max = eachWord.count
                maxString = eachWord
            }
        } 
        return maxString
    }
    
    func isValid(_ word: String, in hash: inout [String: Contains] ) -> Bool {
        guard word.count > 1 else { return true }
        var stack = [String]()
        
        for i in (0..<word.count-1).reversed() {
            let endIndex = word.index(word.startIndex, offsetBy:i)
            let subWord = String(word[word.startIndex...endIndex])
            
            if let state = hash[subWord] {
                switch state {
                    case .valid: 
                        for each in stack {
                            hash[each] = .valid
                        }
                        return true
                    case .invalid: 
                        for each in stack {
                            hash[each] = .invalid
                        }
                        return false
                    case .unknown: 
                        stack.append(subWord)
                }
            }
            else {
                return false
            }
        }        
        return false
    }
}

---

216ms

class Solution {
    func longestWord(_ words: [String]) -> String {
        var answer = ""
        var wordSet = Set<String>()
        let sortedWords = words.sorted()
        
        for word in sortedWords {
            if word.count == 1 || wordSet.contains(String(word.prefix(word.count-1))) {
                answer = word.count > answer.count ? word : answer
                wordSet.insert(word)
            }
        }
        return answer
    }
}

---

224ms

class Solution {
  func longestWord(_ words: [String]) -> String {
    let hash = Set(words)    
    // Mark all words that can be built from available words
    var longestWord = ""
    for word in hash {      
      guard word.count >= longestWord.count else { continue }
      if word.count == longestWord.count { guard word < longestWord else { continue } }            
      var trunc = word
      var isValid = false
      for _ in 0 ..< word.count {
        if trunc.count == 1 { isValid = hash.contains(trunc); break }        
        trunc = String(trunc.dropLast())
        guard hash.contains(trunc) else { break }
      }
      guard isValid else { continue }
      longestWord = word
    }    
    return longestWord
  }
}