LeetCode-Python-127. 单词接龙

给定两个单词（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" 不在字典中，所以无法进行转换。

第一种思路：

单向BFS搜索，

起点是当前单词，下一个点是当前单词可以变换一位得到的新单词，新单词必须满足在wordList里，求从起点到终点的最短路径。

用BFS求解。每一次循环生成当前单词可以变换到的所有单词，再对满足条件的单词进行入队操作。

from collections import deque
class Solution(object):
    def ladderLength(self, beginWord, endWord, wordList):
        """
        :type beginWord: str
        :type endWord: str
        :type wordList: List[str]
        :rtype: int
        """
        if endWord not in wordList or beginWord == endWord:
            return 0
        visited = set()
        wordList = set(wordList)
        
        q = deque()
        q.append([beginWord, 0])
        
        char = "abcdefghijklmnopqrstuvwxyz"
        while q:
            cur, cnt = q.popleft() #从队列里取一个出来
            if cur == endWord: #如果刚好找到了
                return cnt + 1
               
            for i in range(len(cur)):
                for j in range(26):
                    word = cur[:i] + char[j] + cur[i + 1:] #把26种变换可能都生成
                    if word in wordList and word not in visited: #判断变换有没有效
                        visited.add(word)
                        q.append([word, cnt + 1])
                    
        return 0
                    
            

第二种思路：

双向BFS搜索，

从beginWord和endWord向中间开始找，每次搜索较短的列表用于剪枝，

双向搜索可以有效提高运行效率。 

class Solution(object):
    def ladderLength(self, beginWord, endWord, wordList):
        """
        :type beginWord: str
        :type endWord: str
        :type wordList: List[str]
        :rtype: int
        """
        from collections import deque
        if endWord not in wordList:
            return 0
        wordList = set(wordList) #必备优化，不然超时
        
        res, forward, backward = 2, {beginWord}, {endWord}
        while forward:
            if len(forward) > len(backward):
                forward, backward = backward, forward
                
            next_level = set()
            for word in forward:
                for i in range(len(word)):
                    for k in range(26):
                        tmp = word[:i] + chr(ord("a") + k) + word[i + 1:]
                        
                        if tmp in backward: #找到了，胜利会师
                            return res
                        if tmp in wordList:
                            next_level.add(tmp)
                            wordList.remove(tmp)
            res += 1
            forward = next_level
                            
                        
        return 0