力扣126. 单词接龙 II

按字典 wordList 完成从单词 beginWord 到单词 endWord 转化，一个表示此过程的 转换序列 是形式上像 beginWord -> s1 -> s2 -> … -> sk 这样的单词序列，并满足：

每对相邻的单词之间仅有单个字母不同。
转换过程中的每个单词 si（1 <= i <= k）必须是字典 wordList 中的单词。注意，beginWord 不必是字典 wordList 中的单词。
sk == endWord
给你两个单词 beginWord 和 endWord ，以及一个字典 wordList 。请你找出并返回所有从 beginWord 到 endWord 的 最短转换序列 ，如果不存在这样的转换序列，返回一个空列表。每个序列都应该以单词列表 [beginWord, s1, s2, …, sk] 的形式返回。

示例 1：

输入：beginWord = “hit”, endWord = “cog”, wordList = [“hot”,“dot”,“dog”,“lot”,“log”,“cog”]
输出：[[“hit”,“hot”,“dot”,“dog”,“cog”],[“hit”,“hot”,“lot”,“log”,“cog”]]
解释：存在 2 种最短的转换序列：
“hit” -> “hot” -> “dot” -> “dog” -> “cog”
“hit” -> “hot” -> “lot” -> “log” -> “cog”
示例 2：

输入：beginWord = “hit”, endWord = “cog”, wordList = [“hot”,“dot”,“dog”,“lot”,“log”]
输出：[]
解释：endWord “cog” 不在字典 wordList 中，所以不存在符合要求的转换序列。

提示：

1 <= beginWord.length <= 7
endWord.length == beginWord.length
1 <= wordList.length <= 5000
wordList[i].length == beginWord.length
beginWord、endWord 和 wordList[i] 由小写英文字母组成
beginWord != endWord
wordList 中的所有单词 互不相同

广度优先搜索：

import collections


def ladderLength(beginWord, endWord, wordList):
    if endWord not in wordList:
        return []
    # 队列元素存的是当前单词节点，和到该单词节点的所有的单词路线
    qu = collections.deque([(beginWord, [[beginWord]])])
    while qu:
        # 一层一层的走，队列里只存一层的单词节点
        s = len(qu)
        qui = {} # 这个字典是用来存储下一层的单词节点，入队用的
        for i in range(s):
            a = qu.popleft()
            if a[0] == endWord:
                return a[1]
            f = set()
            for wi in range(len(wordList)):
                if wordList[wi] == '0':
                    continue
                sa = 0
                for j in range(len(a[0])):
                    if a[0][j] != wordList[wi][j]:
                        sa += 1
                    if sa > 1:
                        break
                if sa == 1:  # 等于1 说明能转化，能作为子节点，下面将拼接路线，并将节点存入字典，
                    if wordList[wi] not in qui:
                        qui[wordList[wi]] = [ai + [wordList[wi]] for ai in a[1]]
                    else:  # 如果这个单词在被作为子节点过了，就直接拼接路线即可，不入队两次
                        qui[wordList[wi]] = qui[wordList[wi]] + [ai + [wordList[wi]] for ai in a[1]]
                    f.add(wi)

        # 遍历完这层的节点之后，下面开始入队下一次单词节点
        for quik in qui:
            qu.append((quik, qui[quik]))
            wordList[wordList.index(quik)] = '0'

    return []


print(ladderLength("hit", "cog", ["hot", "dot", "dog", "lot", "log", "cog"]))

# "hit" -> "hot" -> "dot" -> "dog" -> "cog"
# "hit" -> "hot" -> "lot" -> "log" -> "cog"