LeetCode 472连接词：动态规划与DFS实战解析

王饮刀

1. 问题背景与核心挑战

LeetCode 472「连接词」这道题目初看像是一道普通的字符串处理题，但实际上它考察的是对字典和动态规划/深度优先搜索的综合运用能力。题目要求我们从一个不包含重复单词的数组中，找出所有能够由数组中至少两个更短单词拼接而成的连接词。

在实际工程场景中，这类问题非常常见。比如在搜索引擎中，我们需要将用户输入的复合词拆分为更基础的词汇进行检索；在自然语言处理中，分词系统需要判断一个长词是否由多个词典中的基础词组成；在用户输入校验系统中，我们需要检查某个输入是否由多个黑名单词汇组合而成。

这道题的核心难点在于：

需要高效判断一个单词能否由其他单词组成
要避免自己拆分自己的情况
需要处理大量可能的拆分组合而不超时

2. 解题思路与算法选择

2.1 基础思路解析

最直观的解决思路可以分解为以下几步：

将所有单词存入一个哈希集合(Set)以便快速查找
对每个单词，判断它是否能由集合中其他单词拼接而成
收集所有满足条件的单词

然而，这种朴素的方法存在几个严重问题：

如果不做任何优化，时间复杂度会非常高
可能会出现一个单词用自己来拆分自己的情况
对于长单词，会有大量重复的子问题计算

2.2 关键优化策略

为了解决上述问题，我们需要引入几个关键优化：

预处理排序：将所有单词按长度从小到大排序。这样可以确保在处理长词时，所有可能用于拼接它的短词都已经在字典中了。
动态构建字典：在处理每个单词前，先检查它是否能被当前字典中的词拼接，然后再将它加入字典。这样可以避免使用自己拆分自己的情况。
高效判断方法：对于单个单词能否被拼接的判断，我们有两种主流选择：
- 动态规划(DP)方法
- 深度优先搜索(DFS)配合记忆化

在Swift实现中，DFS配合记忆化的方法通常更直观且易于实现，这也是我们最终选择的方案。

3. 代码实现与详细解析

3.1 主函数实现

swift复制class Solution {
    func findAllConcatenatedWordsInADict(_ words: [String]) -> [String] {
        // 按长度排序，短词优先
        let sortedWords = words.sorted { $0.count < $1.count }
        var wordSet = Set<String>()
        var result: [String] = []

        for word in sortedWords {
            if word.isEmpty { continue }

            if canForm(word, wordSet) {
                result.append(word)
            }
            wordSet.insert(word)
        }

        return result
    }
}

主函数的逻辑非常清晰：

首先对输入单词按长度排序
初始化一个空字典集合和一个结果数组
遍历排序后的单词，对每个单词：
- 跳过空字符串
- 检查是否能被当前字典中的词拼接
- 如果能，加入结果数组
- 无论能否拼接，都将该词加入字典

3.2 核心判断函数实现

swift复制private func canForm(_ word: String, _ dict: Set<String>) -> Bool {
    if dict.isEmpty { return false }
    
    let chars = Array(word)
    var memo = Array(repeating: false, count: chars.count)
    
    func dfs(_ start: Int) -> Bool {
        if start == chars.count {
            return true
        }
        
        if memo[start] {
            return false
        }
        
        var current = ""
        for i in start..<chars.count {
            current.append(chars[i])
            if dict.contains(current) {
                if dfs(i + 1) {
                    return true
                }
            }
        }
        
        memo[start] = true
        return false
    }
    
    return dfs(0)
}

这个函数是算法的核心，它使用DFS配合记忆化来判断一个单词是否能被字典中的词拼接：

输入处理：首先将字符串转换为字符数组，并初始化记忆化数组
DFS函数：定义嵌套的dfs函数，从给定位置开始尝试各种可能的拆分
记忆化：memo数组记录从某个位置开始是否已经确定无法拆分，避免重复计算
递归过程：逐步构建当前子串，如果在字典中，则递归检查剩余部分

3.3 关键实现细节

排序的重要性：
- 确保处理长词时，所有可能组成它的短词已经在字典中
- 避免一个词被自己拆分的情况
- 这与自然语言处理中先构建基础词典再分析复合词的流程一致
记忆化技术：
- memo数组记录从某个位置开始无法拆分的状态
- 当再次访问该位置时可以直接返回失败
- 这大幅减少了重复计算，是性能优化的关键
DFS与DP的选择：
- 虽然DP方法也可以解决，但在Swift中DFS实现更直观
- DFS更符合"尝试各种拆分可能"的自然思路
- 配合记忆化后，其效率与DP相当

4. 复杂度分析与性能考量

4.1 时间复杂度分析

设：

n为单词数量
L为单词最大长度

对于单个单词的DFS判断：

最坏情况下需要检查所有可能的拆分点
每个字符位置都可能作为拆分点
配合记忆化后，每个子问题只计算一次
因此单个单词的时间复杂度为O(L²)

整体复杂度：

需要对n个单词分别进行判断
因此总时间复杂度为O(n * L²)

在题目给定的约束条件下（总字符数≤1e5），这个复杂度是完全可接受的。

4.2 空间复杂度分析

主要空间消耗来自：

存储所有单词的Set：O(n * L)
DFS过程中的记忆化数组：O(L)
递归调用的栈空间：最坏O(L)

因此总空间复杂度为O(n * L)，在合理范围内。

4.3 实际性能优化技巧

在实际编码面试或工程实现中，还可以考虑以下优化：

提前终止条件：
- 如果当前剩余长度小于字典中最短词长度，可以直接返回失败
- 这需要额外维护字典中的最小长度信息
双指针优化：
- 对于特别长的单词，可以考虑从两端同时进行搜索
- 这在某些情况下可以减少搜索空间
并行处理：
- 对于大规模数据，可以并行处理不同的单词
- 但需要注意线程安全和资源竞争问题

5. 测试用例与边界情况

5.1 标准测试用例

swift复制let solution = Solution()

let words1 = [
    "cat","cats","catsdogcats",
    "dog","dogcatsdog",
    "hippopotamuses",
    "rat","ratcatdogcat"
]

print(solution.findAllConcatenatedWordsInADict(words1))
// 预期输出: ["catsdogcats", "dogcatsdog", "ratcatdogcat"]

let words2 = ["cat","dog","catdog"]
print(solution.findAllConcatenatedWordsInADict(words2))
// 预期输出: ["catdog"]

5.2 边界情况测试

空输入测试：

swift复制print(solution.findAllConcatenatedWordsInADict([]))
// 预期输出: []

包含空字符串：

swift复制print(solution.findAllConcatenatedWordsInADict(["", "cat", "dog", "catdog"]))
// 预期输出: ["catdog"]

无连接词情况：

swift复制print(solution.findAllConcatenatedWordsInADict(["a", "b", "c"]))
// 预期输出: []

重复使用同一单词：

swift复制print(solution.findAllConcatenatedWordsInADict(["a", "aa", "aaa"]))
// 预期输出: ["aa", "aaa"]

5.3 性能测试

对于大规模数据测试，可以构造如下用例：

swift复制// 生成10000个随机短词
var largeInput = (1...10000).map { _ in 
    String((0..<3).map { _ in "abcdefghij".randomElement()! })
}

// 添加一些由这些短词组成的长词
largeInput += [
    largeInput[0] + largeInput[1],
    largeInput[2] + largeInput[3] + largeInput[4],
    largeInput[5] + largeInput[6]
]

// 测试算法性能
let start = Date()
_ = solution.findAllConcatenatedWordsInADict(largeInput)
let duration = Date().timeIntervalSince(start)
print("处理10000个单词耗时: \(duration)秒")