BFS解决单词接龙问题：无权图最短路径实战

1. 为什么单词接龙问题必须用BFS？

第一次看到LeetCode 127题时，我下意识想用DFS暴力搜索所有可能的转换路径。直到提交后超时，才意识到这题被标记为"Hard"的真正原因——它本质上是个无权图最短路径问题，而BFS才是解决这类问题的银弹。

1.1 问题本质的图论视角

把每个单词看作图中的一个节点，如果两个单词只有一个字母不同（比如"hot"和"dot"），就在它们之间画一条边。这样整个词表就构成了一张无向无权图，而题目要求的就是从起点词到终点词的最短路径长度。

关键洞察：在无权图中，边的权重可以视为1，此时最短路径等价于经过最少节点的路径

1.2 DFS为什么不适合？

我最初用DFS的实现是这样的：

python复制def ladderLength(beginWord, endWord, wordList):
    min_length = float('inf')
    
    def dfs(current, path):
        nonlocal min_length
        if current == endWord:
            min_length = min(min_length, len(path))
            return
        for word in wordList:
            if is_adjacent(current, word) and word not in path:
                dfs(word, path + [word])
    
    dfs(beginWord, [beginWord])
    return min_length if min_length != float('inf') else 0

这种解法会遍历所有可能的路径，时间复杂度达到O(N!)。当词表较大时（比如测试用例里500个单词），必然超时。

1.3 BFS的层序遍历优势

BFS的解法则优雅得多：

python复制from collections import deque

def ladderLength(beginWord, endWord, wordList):
    wordSet = set(wordList)
    if endWord not in wordSet:
        return 0
    
    queue = deque([(beginWord, 1)])
    while queue:
        word, length = queue.popleft()
        if word == endWord:
            return length
        for i in range(len(word)):
            for c in 'abcdefghijklmnopqrstuvwxyz':
                next_word = word[:i] + c + word[i+1:]
                if next_word in wordSet:
                    wordSet.remove(next_word)
                    queue.append((next_word, length + 1))
    return 0

BFS保证第一次到达终点时的路径长度就是最短的，时间复杂度为O(N*L^2)，其中N是词表大小，L是单词长度。

2. BFS在无权图中的数学证明

2.1 Dijkstra算法的特例

Dijkstra算法在无权图中会退化成BFS。因为所有边的权重相同（可视为1），优先队列中的距离值总是单调递增的，此时BFS的队列行为与Dijkstra完全一致。

2.2 层序遍历的最优性证明

用数学归纳法可以证明：

• 基础步：起点距离为0（正确）
• 归纳步：假设第k层所有节点距离起点最短距离为k，则第k+1层节点必须通过第k层节点到达，距离为k+1

这个性质在有权图中不成立，但在无权图中完美适用。

3. 算法优化实战技巧

3.1 双向BFS加速

当知道起点和终点时，可以从两端同时进行BFS：

python复制def ladderLength(beginWord, endWord, wordList):
    if endWord not in wordList:
        return 0
    
    wordSet = set(wordList)
    beginQueue = {beginWord}
    endQueue = {endWord}
    length = 1
    
    while beginQueue:
        length += 1
        next_queue = set()
        for word in beginQueue:
            for i in range(len(word)):
                for c in 'abcdefghijklmnopqrstuvwxyz':
                    next_word = word[:i] + c + word[i+1:]
                    if next_word in endQueue:
                        return length
                    if next_word in wordSet:
                        wordSet.remove(next_word)
                        next_queue.add(next_word)
        beginQueue = next_queue
        if len(beginQueue) > len(endQueue):
            beginQueue, endQueue = endQueue, beginQueue
    return 0

实测速度提升2-5倍，因为搜索空间从O(b^d)降到了O(b^(d/2))，其中b是分支因子，d是路径深度。

3.2 预处理邻接表

对于大型词表，可以预先构建邻接关系：

python复制from collections import defaultdict

def build_adjacency(wordList):
    adj = defaultdict(list)
    for word in wordList:
        for i in range(len(word)):
            pattern = word[:i] + '*' + word[i+1:]
            adj[pattern].append(word)
    return adj

这样查询相邻单词时只需O(L)时间，而不是O(N*L)。

4. 常见错误与调试技巧

4.1 忘记处理终点不在词表的情况

这是最常见的错误之一。必须在开始时检查：

python复制if endWord not in wordList:
    return 0

4.2 未及时移除已访问节点

如果不及时从wordSet中移除已访问节点，会导致：

• 重复访问同一节点
• 形成环路无限循环
• 错误地认为找到了更短路径

4.3 字符替换的边界条件

在生成相邻单词时要注意：

• 不要生成与原单词相同的词（浪费计算资源）
• 小写字母范围要完整（有些实现漏掉某些字母）
• 确保生成的单词长度不变

5. 复杂度分析与变种问题

5.1 时间复杂度详解

标准BFS版本：

• 每个单词处理L个位置
• 每个位置尝试26个字母
• 总复杂度O(NL26) = O(N*L)

预处理邻接表版本：

• 构建邻接表O(N*L)
• 搜索过程O(N*L)

5.2 相关变种题目

1. 126. Word Ladder II：要求输出所有最短路径
2. 433. Minimum Genetic Mutation：基因序列突变问题
3. 752. Open the Lock：解锁密码问题

这些题目都可以套用相同的BFS框架解决。

6. 从算法选择看编程思维

在解决这个问题时，我经历了典型的思维进阶：

1. 暴力尝试（DFS回溯）
2. 发现性能问题（超时）
3. 分析问题本质（图的最短路径）
4. 选择合适算法（BFS）
5. 进一步优化（双向BFS、预处理）

这个过程教会我：遇到问题时，先花时间分析问题结构，比直接写代码更重要。理解"为什么用BFS"比记住"怎么用BFS"更有长远价值。