在给定列表中搜索将字符串转换为另一个字符串的最短方法，一次一个字符

Question

给定一个具有 SAME 长度的字符串list，寻找一种方法将start 字符串转换为end 字符串，一次一个字符，这样每个转换后的字符串都是仍然存在于字符串的list 中。

输入！
输入以T 开头表示测试用例的数量。然后，在另一行中出现m 询问要放入列表的字符串数。 m 后面的行要求相同长度的字符串，然后，最后一行由start 和end 组成，以空格分隔。

例子：

List: ["booster", "rooster", "roaster", "coaster", "coasted"] 
start: roaster
end: booster

Number of String Transformation: 3 (roaster -> rooster -> booster)


List: ["booster", "rooster", "roaster", "coaster", "coasted"] 
start: booster
end: coasted

Number of String Transformation: 3 (booster -> rooster -> roaster -> coaster -> coasted)


List: ["booster", "rooster", "roaster", "coaster", "coasted", "coastal"] 
start: roaster
end: coastal

Number of String Transformation: impossible (roaster -> coaster -> coasted -> x -> coastal)

如果没有可能，输出impossible。否则，输出最短方式进行变换。

我采用了一种递归方法，但这无法找到所有可能的解决方案，因为它只尝试更改与 end 字符串不相等的索引，这会跳过 list 中存在的一些字符串，这可能导致解决方案。

我的代码适用于第一个示例，但错过了第二个示例，因为它没有尝试 (booster -> rooster -> etc...)，因为它只将 (booster -> cooster -> coaster -> coasted) 视为可能的解决方案。我有点卡住了，我不知道如何解决这个问题。有人可以告诉我更好的方法吗？

def transformable(word_1, word_2):
    return len([i for i in range(len(word_1)) if word_1[i] != word_2[i]]) == 1

def shortest_transformation(start, end, words):
    queue = [[start]]
    available = set(words).difference({start})
    while queue:
        path = queue.pop()
        if transformable(path[-1], end):
            return path + [end]
        transformables = set(word for word in available if transformable(path[-1], word))
        queue = [path + [word] for word in transformables] + queue
        available = available.difference(transformables)
    return None

T = int(input())

for case in range(T):
    m = int(input())
    words = []
    for inputs in range(m):
        words.append(input())
    
    start, end = input().split()
    
    result = shortest_transformation(start, end, words)
    print(len(result)) if result else print("none")

4
5
booster
rooster
roaster
coaster
coastal
booster coastal
6
booster
rooster
roaster
coaster
coasted
coastal
booster coastal
5
booster
rooster
roaster
coaster
coasted
booster coasted
5
booster
rooster
roaster
coaster
coasted
roaster booster

Output:
none
none
5
3

Answer 1

如果您还没有找到解决方案，这里有一个建议：

from collections import deque

def transformable(word_1, word_2):
    return len([i for i in range(len(word_1)) if word_1[i] != word_2[i]]) == 1

def shortest_transformation(start, end, words):
    queue = deque([[start]])
    words = set(words).difference({start})
    while queue:
        path = queue.pop()
        if transformable(path[-1], end):
            return path + [end]
        transformables = set(word for word in words if transformable(path[-1], word))
        queue.extendleft(path + [word] for word in transformables)
        words = words.difference(transformables)
    return []

这是一种广度优先搜索（通过使用deque 的.extendleft() 方法的LILO/FIFO 队列），这是搜索最短路径的好方法。

你的例子

words = ["booster", "rooster", "roaster", "coaster", "coasted"] 
start = 'roaster'
end = 'booster'
print(shortest_transformation(start, end, words))

words = ["booster", "rooster", "roaster", "coaster", "coasted"] 
start = 'booster'
end = 'coasted'
print(shortest_transformation(start, end, words))

words = ["booster", "rooster", "roaster", "coaster", "coasted", "coastal"] 
start = 'roaster'
end = 'coastal'
print(shortest_transformation(start, end, words))

输出是

['roaster', 'rooster', 'booster']
['booster', 'rooster', 'roaster', 'coaster', 'coasted']
[]

如果您不想使用deque，那么这应该是等效的：

def shortest_transformation(start, end, words):
    queue = [[start]]
    available = set(words).difference({start})
    while queue:
        path = queue.pop()
        if transformable(path[-1], end):
            return path + [end]
        transformables = set(word for word in available if transformable(path[-1], word))
        queue = [path + [word] for word in transformables] + queue
        available = available.difference(transformables)
    return None