126. Solitario de Palabras
Dadas dos palabras (beginWord y endWord) y una lista de palabras del diccionario, averigüe todas las secuencias de conversión más cortas desde beginWord hasta endWord. La conversión debe seguir las siguientes reglas: Solo se puede cambiar una letra por conversión. Las palabras obtenidas después de la conversión deben ser palabras del diccionario. Explicación: Si no existe tal secuencia de conversión, se devuelve una lista vacía. Todas las palabras tienen la misma longitud. Todas las palabras constan únicamente de letras minúsculas. No hay palabras duplicadas en el diccionario. Puede asumir que beginWord y endWord no están vacíos y no son lo mismo.
示例 1: 输入: beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log","cog"] 输出: [ ["hit","hot","dot","dog","cog"], ["hit","hot","lot","log","cog"] ] 示例 2: 输入: beginWord = "hit" endWord = "cog" wordList = ["hot","dot","dog","lot","log"] 输出: []
Explicación: endWord "cog" no está en el diccionario, por lo que no hay una secuencia de conversión que cumpla con los requisitos.
Código
1 Primero, la última versión final se basa en realidad en el código del jefe
class Solution2:
def findLadders(self, beginWord, endWord, wordList):
if endWord not in wordList:
return 0
s1 = {beginWord}
s2 = {endWord}
step = 0
while s1 and s2:
if len(s1)>len(s2):s1, s2 = s2, s1
step += 1
s = set()
for preword in s1:
n = len(preword)
next_words = [preword[:i] + chr(j) + preword[i+1:] for j in range(97, 123) for i in range(n)]
for word in next_words:
if word in s2:
return step + 1
if word not in wordList:
continue
wordList.remove(word)
s.add(word)
s1 = s
return 0
Entonces habla de mi viaje mental
Al principio me di cuenta de que no había idea para esta pregunta y me resultó demasiado problemático formularla. . . Puede estar un poco perdido por el problema de la ruta. . . Más tarde, analicé brevemente la idea de resolver el problema. Existe una lógica para reemplazar el vocabulario de mapas. Por ejemplo, clave = "a * b", valor = una palabra en un diccionario que satisface 'a * b' , * significa cualquier carácter, es decir, obtener ¿Cuáles son las palabras con una letra diferente?
class Solution:
def get_word_dic(self, wordList):
dic = dict()
for word in wordList:
for i in range(len(word)):
mark = word[:i] + '*' + word[i + 1:]
dic.setdefault(mark, [])
if word not in dic[mark]:
dic[mark].append(word)
return dic
def find(self, pre_word_lists, endWord, dic):
if len(pre_word_lists)==0:
return []
res = []
level1_word_lists = []
for pre_word_list in pre_word_lists:
beginWord = pre_word_list[-1]
level1_words = set()
for i in range(len(beginWord)):
mark = beginWord[:i] + '*' + beginWord[i + 1:]
if mark not in dic:
continue
if endWord in dic[mark]:
res.append(pre_word_list + [endWord])
level1_words.update([x for x in dic[mark] if x not in pre_word_list])
level1_word_lists.extend([pre_word_list + [x] for x in level1_words])
if len(res) > 0:
return res
paths = self.find(level1_word_lists, endWord, dic)
if len(paths) > 0:
return paths
return []
def ladderLength(self, beginWord: str, endWord: str, wordList: List[str]) -> int:
if endWord not in wordList:
return 0
dic = self.get_word_dic(wordList)
paths = self.find([[beginWord]], endWord, dic)
if len(paths)==0:
return 0
return len(paths[0])
Se agotó el tiempo, y luego miré los pensamientos de Daniel y escribí el código superior, pero todavía estaba un poco reacio a descubrir dónde estaba lento mi código.
No hace falta decir que sobre el problema bidireccional debe tener un gran impacto, pero después de medir el tiempo, la oración bidireccional si len (s1)> len (s2): s1, s2 = s2, s1 aún se compara. El mío es mucho más rápido.
Lleva mucho tiempo averiguar si lleva mucho tiempo buscar en el diccionario cada vez y cambiarlo a la lógica de reemplazo az en el código superior.
Mirando otros lugares, parece que es el problema de la eliminación del diccionario, además de la operación de eliminación del diccionario, el siguiente código, el envío aún se agotará, pero se han superado más casos de prueba.
class Solution:
def find(self, pre_word_lists, endWord, wordList):
if len(pre_word_lists)==0:
return 0
level1_word_lists = []
for pre_word_list in pre_word_lists:
beginWord = pre_word_list[-1]
nextword = []
for i in range(len(beginWord)):
for j in range(97, 123):
word = beginWord[:i] + chr(j) + beginWord[i + 1:]
if word in wordList and word not in pre_word_list:
nextword.append(word)
wordList.remove(word)
if endWord in nextword:
return len(pre_word_list + [endWord])
level1_word_lists.extend([pre_word_list + [x] for x in nextword])
return self.find(level1_word_lists, endWord, wordList)
def ladderLength(self, beginWord: str, endWord: str, wordList: List[str]) -> int:
if endWord not in wordList:
return 0
return self.find([[beginWord]], endWord, wordList)
Descubrí que al final tenía que cambiarse a bidireccional. De lo contrario, el diccionario es demasiado largo y hay demasiadas rutas. Aún causará un problema explosivo de búsqueda de ruta ...