[Swift]LeetCode127. 单词接龙 | Word Ladder

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

Given two words (beginWord and endWord), and a dictionary's word list, find the length of shortest transformation sequence from beginWord to endWord, such that:

1. Only one letter can be changed at a time.
2. Each transformed word must exist in the word list. Note that beginWord is not a transformed word.

Note:

• Return 0 if there is no such transformation sequence.
• All words have the same length.
• All words contain only lowercase alphabetic characters.
• You may assume no duplicates in the word list.
• You may assume beginWord and endWord are non-empty and are not the same.

Example 1:

Input:
beginWord = "hit",
endWord = "cog",
wordList = ["hot","dot","dog","lot","log","cog"]

Output: 5

Explanation: As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",
return its length 5.

Example 2:

Input:
beginWord = "hit"
endWord = "cog"
wordList = ["hot","dot","dog","lot","log"]

Output: 0

Explanation: The endWord "cog" is not in wordList, therefore no possible transformation.

---

给定两个单词（beginWord 和 endWord）和一个字典，找到从 beginWord 到 endWord 的最短转换序列的长度。转换需遵循如下规则：

1. 每次转换只能改变一个字母。
2. 转换过程中的中间单词必须是字典中的单词。

说明:

• 如果不存在这样的转换序列，返回 0。
• 所有单词具有相同的长度。
• 所有单词只由小写字母组成。
• 字典中不存在重复的单词。
• 你可以假设 beginWord 和 endWord 是非空的，且二者不相同。

示例 1:

输入:
beginWord = "hit",
endWord = "cog",
wordList = ["hot","dot","dog","lot","log","cog"]

输出: 5

解释: 一个最短转换序列是 "hit" -> "hot" -> "dot" -> "dog" -> "cog",
     返回它的长度 5。

示例 2:

输入:
beginWord = "hit"
endWord = "cog"
wordList = ["hot","dot","dog","lot","log"]

输出: 0

解释: endWord "cog" 不在字典中，所以无法进行转换。

---

304ms

class Solution {
    func ladderLength(_ beginWord: String, _ endWord: String, _ wordList: [String]) -> Int {
        if !wordList.contains(endWord) 
        { 
            return 0 
        }
        
        let dict = Set(wordList)
        var beginSet = Set<String>()
        var endSet = Set<String>()
        var visitedSet = Set<String>()
        var length = 1
        var found = false
        
        beginSet.insert(beginWord)
        endSet.insert(endWord)
        
        while !found && !beginSet.isEmpty && !endSet.isEmpty {
            var nextSet = Set<String>()
            //accelerating search speed by swap begin and end
            if beginSet.count > endSet.count {
                swap(&beginSet, &endSet)
            }
            found = helper(beginSet, endSet, dict, &visitedSet, &nextSet)
            beginSet = nextSet
            length += 1
        }
        return found ? length : 0
    }
    
    private func helper(_ beginSet: Set<String>, _ endSet: Set<String>, _ dict: Set<String>,
                        _ visitedSet: inout Set<String>, _ resSet: inout Set<String>) -> Bool {
        
        let alphaArray = Array("abcdefghijklmnopqrstuvwxyz")
        
        for word in beginSet {
            for i in 0 ..< word.count {
                var chars = Array(word)
                for j in 0 ..< alphaArray.count{
                    chars[i] = alphaArray[j]
                    let str = String(chars)
                    if dict.contains(str) {
                        if endSet.contains(str) 
                        { 
                            return true 
                        }
                        if !visitedSet.contains(str) 
                        { 
                            resSet.insert(str)
                            visitedSet.insert(str) 
                        }
                    }
                }
            }
        }
        return false
    }
}

---

884ms

class Solution {
    func ladderLength(_ beginWord: String, _ endWord: String, _ wordList: [String]) -> Int {
        // ensure the endWord is in the wordList
        if !wordList.contains(endWord) {
            return 0
        }

        // build a word map with char array representations
        // this saves an enormous amount of time
        var wordMap: [String: [Character]] = [:]
        for i in 0..<wordList.count {
            // beginWord should never be in the list
            if wordList[i] == beginWord {
                continue
            }
            wordMap[wordList[i]] = [Character](wordList[i].characters)
        }
        
        // we work the problem from the begining forward and end backwards
        // this allows us to deal with the smallest set of possibilities in 
        // both "directions"
        var beginMap:[String: [Character]] = [beginWord: [Character](beginWord.characters)]
        var endMap:[String: [Character]] = [endWord: [Character](endWord.characters)]
        
        // burnedMap bridges what has been used in both beginMap or endMap
        var burnedMap:[String: [Character]] = [:]
        
        // word len is stable throughout the iterations, pay for it only once
        let wordLen = beginWord.count
        
        // mutations tracts how many time mutated on the road from beginWord to endWord
        var mutations = 1

        // we continue while beginMap and endMap are non-empty
        // if one empties, there is no path from beginWord to endWord
        while !beginMap.isEmpty && !endMap.isEmpty {
            // minimize the working set by swapping in the smaller
            // set, we only care about the mutation count
            if beginMap.count > endMap.count {
                let tempMap = beginMap
                beginMap = endMap
                endMap = tempMap
            }

            // track the upcoming set of mutation candidates we're about to create
            var newMap: [String: [Character]] = [:]

            // iterate throught he last set of mutation candidates
            for candidateKV in beginMap {
                let candidateChars = candidateKV.value
                
                // walk through all the remaining (un-burned) valid words
                for wordKV in wordMap {
                    let word = wordKV.key
                    let wordChars = wordKV.value
                    
                    // diff the candidate and valid words looking
                    // fir diffs of 1 character
                    var diffs = 0
                    
                    for i in 0..<wordLen {
                        if candidateChars[i] != wordChars[i] {
                            diffs += 1
                            if diffs > 1 {
                                break
                            }
                        }
                    }
                    
                    // anything other than a diff of 1 is not applicable
                    // in this loop, we can only consider "word" if the
                    // diff is exactly 1
                    if diffs == 1 {
                        // we have a valid 1 character diff, use it
                        
                        if endMap[word] != nil {
                            // base case reached
                            return mutations + 1
                        }
                        
                        if burnedMap[word] == nil {
                            newMap[word] = wordChars
                            burnedMap[word] = wordChars
                        }
                    }
                }
            }
            
            // we already evaluated what was in beginMap, we can 
            // lose those and use the newMap evaluation set 
            beginMap = newMap
            
            // we have completed an additional mutation step
            mutations += 1
        }
        
        return 0
    }
}  

---

1520ms

class Solution {
    func ladderLength(_ beginWord: String, _ endWord: String, _ wordList: [String]) -> Int {
        //Set类型替换数组类型，加速查找
        var wordSet:Set<String> = Set<String>(wordList)
        //构建队列，实现广度优先遍历
        var q:Queue<String> = Queue<String>()
        //加入源顶点
        q.enQueue(beginWord)
        var res:Int = 0
        while (!q.isEmpty())
        {
            for k in (1...q.count).reversed()
            {
                var word:String = q.deQueue()!
                if word == endWord {return res + 1}
                for i in 0..<word.count
                {
                    var newWord:String = word
                    for ch in 97...122
                    {
                        newWord[i] = ch.ASCII 
                        if wordSet.contains(newWord) && newWord != word
                        {
                            q.enQueue(newWord)
                            wordSet.remove(newWord)
                        }
                    }
                }
            }
            res += 1
        }
         return 0
    }
}

//String扩展方法
extension String {
    func toCharArray() -> [Character]
    {
        var arr:[Character] = [Character]()
        for char in self.characters
        {
            arr.append(char)
        }
        return arr
    }
    
    //subscript函数可以检索数组中的值
    //直接按照索引方式截取指定索引的字符
    subscript (_ i: Int) -> Character {
        //读取字符
        get {return self[index(startIndex, offsetBy: i)]}
        
        //修改字符
        set
        {
            var str:String = self
            var index = str.index(startIndex, offsetBy: i)
            str.remove(at: index)
            str.insert(newValue, at: index)
            self = str
        }
    }
}

//Int扩展方法  
extension Int
{
    //属性：ASCII值(定义大写为字符值)
    var ASCII:Character 
    {
        get {return Character(UnicodeScalar(self)!)}
    }
}

public struct Queue<T> {
    
    // 泛型数组：用于存储数据元素
    fileprivate var queue: [T] 

    // 返回队列中元素的个数
    public var count: Int {
        return queue.count
    }
    
    // 构造函数：创建一个空的队列
    public init() {
        queue = [T]()
    }
    
    //通过既定数组构造队列
    init(_ arr:[T]){
        queue = arr
    }
    
    // 检查队列是否为空
    // - returns: 如果队列为空，则返回true，否则返回false
    public func isEmpty() -> Bool {
        return queue.isEmpty
    }
    
    // 入队列操作：将元素添加到队列的末尾
    public mutating func enQueue(_ element: T) {
        queue.append(element)
    }
    
    // 出队列操作：删除并返回队列中的第一个元素
    public mutating func deQueue() -> T? {
        return queue.removeFirst()
    }
}

---

1692ms

class Solution {
    func ladderLength(_ beginWord: String, _ endWord: String, _ wordList: [String]) -> Int {
        
        var wordSet = Set(wordList)
        var level = 0
        var currentLevelWords = [beginWord]
        
        while !currentLevelWords.isEmpty {
            level += 1
            
            var nextLevelWords: [String] = []
            
            for word in currentLevelWords {
                if word == endWord {
                    return level
                }
                
                nextLevelWords += findRelatedWords(word: word, wordSet: &wordSet)
            }
            
            currentLevelWords = nextLevelWords
        }
        
        return 0
    }
    
    private let alphabet = Array("abcdefghijklmnopqrstuvwxyz")
    
    func findRelatedWords(word: String, wordSet: inout Set<String>) -> [String] {
        var relatedWords: [String] = []
        
        var word = word
        var wordIndex = word.startIndex
        while wordIndex < word.endIndex {
            
            let originalCharacter = word[wordIndex]
            
            for character in alphabet {
                word.remove(at: wordIndex)
                word.insert(character, at: wordIndex)
                
                if wordSet.contains(word) {
                    wordSet.remove(word)
                    
                    relatedWords.append(word)
                }
            }
            
            word.remove(at: wordIndex)
            word.insert(originalCharacter, at: wordIndex)
            
            wordIndex = word.index(after: wordIndex)
        }
        
        return relatedWords
    }
}

---

1788ms

class Solution {
    func ladderLength(_ beginWord: String, _ endWord: String, _ wordList: [String]) -> Int {
        
        var wordSet = Set(wordList)
        var currentLevelWords = [beginWord]
        var level = 0
        
        while !currentLevelWords.isEmpty {
            level += 1
            
            var nextLevelWords: [String] = []
            
            for word in currentLevelWords {
                
                if word == endWord {
                    return level
                }
                
                nextLevelWords += findCloseWords(word: word, wordSet: &wordSet)
            }
            
            currentLevelWords = nextLevelWords
        }
        
        return 0
    }
    
    let alphabet = Array("abcdefghijklmnopqrstuvwxyz")
    
    func findCloseWords(word: String, wordSet: inout Set<String>) -> [String] {
        
        var closeWords: [String] = []
        
        var word = word
        var wordIndex = word.startIndex
        
        while wordIndex < word.endIndex {
            
            let originalCharacter = word[wordIndex]
            
            for character in alphabet {
                word.remove(at: wordIndex)
                word.insert(character, at: wordIndex)
                
                if wordSet.contains(word) {
                    closeWords.append(word)
                    wordSet.remove(word)
                }
            }
            
            word.remove(at: wordIndex)
            word.insert(originalCharacter, at: wordIndex)
            
            wordIndex = word.index(after: wordIndex)
        }
        
        return closeWords
    }
}

---

2284ms

class Solution {
    func ladderLength(_ beginWord: String, _ endWord: String, _ wordList: [String]) -> Int {
        var queue = [beginWord]
        var wordList = Set(wordList)
        var length = 1

        while !queue.isEmpty && !wordList.isEmpty {
            let count = queue.count
            for _ in 0..<count {
                let word = queue.removeFirst()

                let validTransforms = validTransformations(word, wordList)
                for nextWord in validTransforms {
                    if nextWord == endWord {
                        return length + 1
                    }
                    wordList.remove(nextWord)
                    queue.append(nextWord)
                }
            }

            length += 1
        }

        return 0
    }
    
    func validTransformations(_ word: String, _ wordList: Set<String>) -> [String] {
        var result = [String]()
        let alpahabetArray = Array("abcdefghijklmnopqrstuvwxyz".characters)
        for i in 0 ..< word.characters.count {
            var chars = Array(word.characters)
            for j in 0 ..< alpahabetArray.count {
                chars[i] = alpahabetArray[j]
                let newWord = String(chars)
                if wordList.contains(newWord) {
                    result.append(newWord)
                }
            }
        }

        return result
    }
}

---

3624ms

class Solution {
    
    var letters = "abcdefghijklmnopqrstuvwxyz"
    func ladderLength(_ beginWord: String, _ endWord: String, _ wordList: [String]) -> Int {
        // var map: [String:Set<String>] = [:]
        
        
        var wordSet = Set<String>(wordList)
        // wordSet.insert(endWord)
        var queue: [[String]] = [[beginWord]]
        var visited: Set<String> = []
        var ans = 1
        while !queue.isEmpty {
            var words = queue.removeLast()
            var construction: [String] = []
            for curr in words {
                // print(curr)
                if !visited.contains(curr) {
                    if curr == endWord {return ans}
                    var wordsToAdd = getWords(curr, wordSet)
                    // var wordsToAdd = Array(map[curr] ?? [])
                    construction.append(contentsOf: wordsToAdd)
                    visited.insert(curr)
                }
            }
            if !construction.isEmpty {queue.insert(construction, at: 0)}
            ans += 1
        }
        return 0
    }
    
    func getWords(_ str1: String, _ validWords: Set<String>) -> [String] {
        var ans : [String] = []
        var strArr = Array(str1)
        var lettersArr = Array(letters)
        for i in 0..<str1.count {
            for j in 0..<lettersArr.count {
                var temp = strArr[i]
                strArr[i] = lettersArr[j]
                var newStr = String(strArr)
                if validWords.contains(newStr) {
                    ans.append(String(strArr))
                }
                strArr[i] = temp
            }
        }
        return ans
    }
    
    func isOneAway(_ str1: String, _ str2: String) -> Bool {
        var arr1 = Array(str1), arr2 = Array(str2)
        for i in 0..<arr1.count {
            if arr1[i] != arr2[i] {
                arr1[i] = arr2[i]
                return arr1 == arr2
            }
        }
        return false
    }
}

---

3984ms

class Solution {
    func ladderLength(_ beginWord: String, _ endWord: String, _ wordList: [String]) -> Int {
        guard wordList.contains(endWord) else {
            return 0
        }
        
        var wordMap: [String: Int] = [:]
        for word in wordList {
            wordMap[word] = 1
        }
        
        var sequence: [String] = [beginWord]
        var map: [String: Int] = [beginWord : 1]
        let letters = ["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"]
        
        while sequence.count > 0 {
            
            let bw = sequence.removeFirst()
            
            let level = map[bw]!
            
            let bws: [Character] = [Character](bw)
            for i in 0..<bws.count {
                var chas = bws
                for c in letters {
                    if bws[i] != Character(c) {
                        chas[i] = Character(c)
                        let word = String(chas)
                        
                        if word == endWord {
                            return level + 1
                        }
                        
                        if wordMap[word] != nil && map[word] == nil {
                            map[word] = level+1
                            sequence.append(word)
                        }
                    }
                }
            }
        }

        return 0
    }
}