LeetCode 839题：相似字符串组的并查集解法

1. 问题背景与核心概念

今天遇到一道很有意思的图论问题——LeetCode 839题"相似字符串组"。题目给定一个字符串列表，要求我们找出其中互为"相似字符串"的组合数量。这里的"相似字符串"定义为：两个字符串恰好有两个位置的字符不同（且这两个字符恰好互换位置）。

举个例子，"tars"和"rats"就是相似字符串，因为交换第1个'r'和第2个'a'就能互相转换。而"star"与"tars"则不是，因为它们有超过两处不同。这个问题本质上是要我们把所有能通过这种相似关系连接起来的字符串划分到同一个组里。

2. 问题抽象与算法选择

2.1 图论模型构建

这个问题可以很自然地建模为图论中的连通分量问题。把每个字符串看作图中的一个节点，如果两个字符串满足相似关系（即恰好两个字符位置不同且可以互换），就在它们之间画一条边。那么问题的解就是这个图中的连通分量数量。

举个例子，对于输入["tars","rats","arts","star"]，我们可以建立如下连接：

• tars -- rats (相似)
• rats -- arts (相似)
• tars和star不相连
• arts和star不相连

这样形成的图有两个连通分量：{tars, rats, arts}和{star}，所以答案是2。

2.2 算法选择与复杂度分析

对于连通分量问题，我们有两个主要选择：深度优先搜索(DFS)或并查集(Union-Find)。考虑到字符串数量可能很大（题目提示最多2000个），我们需要选择更高效的算法。

DFS的时间复杂度是O(V+E)，在最坏情况下（完全图）会达到O(n²)。而并查集在路径压缩和按秩合并优化下，每个操作接近常数时间，整体复杂度约为O(n²α(n))，其中α(n)是反阿克曼函数，增长极其缓慢。因此并查集是更优的选择。

3. 并查集实现详解

3.1 并查集基础结构

并查集需要支持两个主要操作：

1. find(x): 查找x的根节点
2. union(x, y): 合并x和y所在的集合

我们先实现基础的并查集结构：

python复制class UnionFind:
    def __init__(self, size):
        self.parent = list(range(size))
        self.rank = [0] * size
    
    def find(self, x):
        if self.parent[x] != x:
            self.parent[x] = self.find(self.parent[x])  # 路径压缩
        return self.parent[x]
    
    def union(self, x, y):
        x_root = self.find(x)
        y_root = self.find(y)
        
        if x_root == y_root:
            return  # 已经在同一集合
        
        # 按秩合并
        if self.rank[x_root] < self.rank[y_root]:
            self.parent[x_root] = y_root
        else:
            self.parent[y_root] = x_root
            if self.rank[x_root] == self.rank[y_root]:
                self.rank[x_root] += 1

3.2 相似性检测函数

关键的一步是判断两个字符串是否相似。我们需要编写一个辅助函数：

python复制def is_similar(a, b):
    if len(a) != len(b):
        return False
    
    diff = []
    for i in range(len(a)):
        if a[i] != b[i]:
            diff.append(i)
            if len(diff) > 2:
                return False
    
    return len(diff) == 2 and a[diff[0]] == b[diff[1]] and a[diff[1]] == b[diff[0]]

这个函数的工作原理是：

1. 首先检查长度是否相同
2. 记录所有不同字符的位置
3. 如果不同位置超过2个，立即返回False
4. 最后检查是否恰好两个不同位置，且这两个位置的字符可以互换

3.3 主算法实现

现在我们可以组合这些组件来解决整个问题：

python复制def num_similar_groups(strs):
    n = len(strs)
    uf = UnionFind(n)
    
    for i in range(n):
        for j in range(i+1, n):
            if is_similar(strs[i], strs[j]):
                uf.union(i, j)
    
    # 统计不同根节点的数量
    roots = set()
    for i in range(n):
        roots.add(uf.find(i))
    
    return len(roots)

4. 优化与性能分析

4.1 时间复杂度优化

上述实现的时间复杂度是O(n²L)，其中n是字符串数量，L是字符串长度。对于n=2000，L=100的情况，这大约是4亿次操作，在Python中可能会超时。

我们可以进行以下优化：

1. 提前检查字符串是否完全相同，相同则直接合并
2. 在is_similar函数中尽早返回

优化后的is_similar函数：

python复制def is_similar(a, b):
    if a == b:
        return True  # 完全相同也算相似
    
    if len(a) != len(b):
        return False
    
    diff = []
    for i in range(len(a)):
        if a[i] != b[i]:
            diff.append(i)
            if len(diff) > 2:
                return False
    
    return len(diff) == 2 and a[diff[0]] == b[diff[1]] and a[diff[1]] == b[diff[0]]

4.2 空间复杂度分析

并查集需要O(n)的额外空间存储parent和rank数组。is_similar函数只需要O(1)的额外空间（diff列表最多存储2个元素）。因此总体空间复杂度是O(n)，非常高效。

5. 边界情况与测试用例

5.1 常见边界情况

1. 空输入：[] → 应该返回0
2. 单个字符串：["abc"] → 应该返回1
3. 所有字符串相同：["a", "a", "a"] → 应该返回1
4. 没有相似字符串：["abc", "def", "ghi"] → 应该返回3
5. 所有字符串都相似：["abc", "bac", "cba"] → 应该返回1

5.2 测试用例实现

python复制test_cases = [
    ([], 0),
    (["tars","rats","arts","star"], 2),
    (["omv","ovm"], 1),
    (["abc","def","ghi"], 3),
    (["a","a","a"], 1),
    (["abc","bac","cba"], 1)
]

for strs, expected in test_cases:
    result = num_similar_groups(strs)
    print(f"Input: {strs}, Output: {result}, Expected: {expected}")
    assert result == expected

6. 实际编码中的注意事项

1. 字符串长度检查：虽然题目保证所有字符串长度相同，但在实际工程中应该先验证这一点
2. 并查集初始化：parent数组初始时每个元素指向自己，这一点很容易出错
3. 路径压缩：在find操作中实现路径压缩可以显著提高后续查询速度
4. 按秩合并：这虽然不是必须的，但能保持树的平衡，提高效率
5. 相似性判断优化：尽早返回可以节省大量不必要的比较

7. 算法扩展与变种

这个问题有几个有趣的变种：

1. 放宽相似条件：如果定义相似为"最多k处不同"，该如何修改算法？

   • 只需要修改is_similar函数，把条件从==2改为<=k
   • 但要注意当k较大时，相似字符串对会增多，可能导致更多合并

2. 计算最大连通分量大小：

   • 在并查集中维护每个集合的大小
   • 在union操作时更新大小
   • 最后遍历找出最大的集合

3. 动态添加字符串：

   • 如果需要支持动态添加字符串并实时查询连通分量数量
   • 可以维护一个哈希表记录字符串到索引的映射
   • 每次添加新字符串时检查它与已有字符串的相似性

8. 性能对比实验

为了验证我们的优化效果，我做了以下实验（在LeetCode测试用例上）：

可以看到，虽然理论时间复杂度相同，但优化后的实际运行时间有明显改善。

9. 其他语言实现要点

对于其他语言的实现，需要注意：

1. C++：

   • 使用vector实现parent和rank数组
   • 注意字符串比较可以直接用==运算符

2. Java：

   • 字符串比较用equals()方法
   • 并查集可以用数组实现

3. JavaScript：

   • 注意字符串是不可变的
   • 并查集可以用普通数组实现

10. 总结与个人体会

这道题很好地展示了如何将一个看似复杂的字符串问题转化为经典的图论问题。在实际解决过程中，我有几点深刻体会：

1. 问题抽象能力是关键。能够识别出这个问题本质上是求图的连通分量，就成功了一大半。

2. 算法选择很重要。虽然DFS也能解决，但并查集在这种场景下更高效。

3. 优化细节决定实际性能。比如提前检查字符串相同、在is_similar中尽早返回等优化，能显著提升实际运行速度。

4. 边界情况考虑要全面。特别是空输入、所有字符串相同等情况容易遗漏。

最后，对于这类问题，我建议先在纸上画出几个小例子，明确相似关系的传递性，这样能更好地理解为什么可以用并查集来解决。在实际编码前，先确保完全理解了问题要求和算法思路，这样可以避免很多后期的调试时间。