[leetcode每日一题2021/1/31]839. 相似字符串组【困难】并查集

题目来源于leetcode，解法和思路仅代表个人观点。传送门。
难度：困难
tag: 并查集

题目

如果交换字符串 X 中的两个不同位置的字母，使得它和字符串 Y 相等，那么称 X 和 Y 两个字符串相似。如果这两个字符串本身是相等的，那它们也是相似的。

例如，“tars” 和 “rats” 是相似的 (交换 0 与 2 的位置)； “rats” 和 “arts” 也是相似的，但是 “star” 不与 “tars”，“rats”，或 “arts” 相似。

总之，它们通过相似性形成了两个关联组：{“tars”, “rats”, “arts”} 和 {“star”}。注意，“tars” 和 “arts” 是在同一组中，即使它们并不相似。形式上，对每个组而言，要确定一个单词在组中，只需要这个词和该组中至少一个单词相似。

给你一个字符串列表 strs。列表中的每个字符串都是 strs 中其它所有字符串的一个字母异位词。请问 strs 中有多少个相似字符串组？

示例 1：

输入：strs = ["tars","rats","arts","star"]
输出：2

示例 2：

输入：strs = ["omv","ovm"]
输出：1

提示：

1 <= strs.length <= 100
1 <= strs[i].length <= 1000
sum(strs[i].length) <= 2 * 10⁴
strs[i] 只包含小写字母。
strs中的所有单词都具有相同的长度，且是彼此的字母异位词。

备注：

字母异位词（anagram），一种把某个字符串的字母的位置（顺序）加以改换所形成的新词。

思路

经过1月并查集的洗礼，基本上可以想到。

1. 字符串【相似】具有传递性。
2. 【相似】的字符串构成一组，即在同一连通分量中
3. 题目就是问，连通分量的个数，即使用并查集。

---

那么就是需要，

1. 构建并查集
2. 遍历两两字符串，判断两个字符串是否【相似】

---

构建并查集，可以使用两种优化方式

• 路径压缩（查找find操作的优化）：
  • 隔代压缩：多次之后，效果和完全压缩相近。一般都用这个。
  • 完全压缩
• 按秩合并（合并join操作的优化）：秩小的根 指向 秩大的根，合并之后 秩（树高）不会发生变化（不会增加）。

---

判断字符串是否【相似】
一开始没有想到更简单的办法，直接枚举$C_m^2$种可能，之后就超时了。

更简单的办法就是，遍历一次字符串。找到两个位置不同的字符【交换】，如果【字符串a】==【字符串b】，就是【相似】。

但是，根据题目给的条件，还有以下结论：

1. 不可能出现奇数个字符不相同
2. 由于单词都是【异位】得来的，如果仅有两个不同，就是相似。

代码

class Solution {
public:
    class UnionFind{
    public:
        vector<int> parent;
        vector<int> rank;
        UnionFind(int N){
            parent.resize(N);
            rank.resize(N);
            for(int i=0;i<N;i++){
                parent[i] = i;
                rank[i] = 0;
            }
        }
        int find(int x){
            while(parent[x] != x){
                //路径压缩
                parent[x] = parent[parent[x]];
                x = parent[x];
            }
            return x;
        }
        void join(int x,int y){
            int rootX = find(x);
            int rootY = find(y);
            //按秩合并
            if(rank[rootX]>rank[rootY]){
                parent[rootY] = rootX;
            }else{
                parent[rootX] = rootY;
                if(rank[rootX] == rank[rootY]){
                    rank[rootY]++;
                }
            }
        }
        bool isConnected(int x,int y){
            return find(x) == find(y);
        }
    };
    //判断两个字符是否相似
    //不可能出现奇数个字符不相等
    //传递两个临时变量，交换之后，不用交换回去
    //由于单词都是异位得来的，仅有两个不同，就是相似
    bool isSimilar(string a,string b){
        //a，b长度相同
        int cnt = 0;
        for(int i=0;i<a.length();i++){
            if(a[i] != b[i]){
                cnt++;
                if(cnt > 2){
                    //如果超过2个字符不相等
                    return false;
                }
            }
        }
        return true;
    }
    int numSimilarGroups(vector<string>& strs) {
        //字符串的数量
        int N = strs.size();
        UnionFind uf(N);
        //初始为N个连通分量
        int ans = N;
        for(int i=0;i<N;i++){
            for(int j=i+1;j<N;j++){
                //先判断，如果不连通
                if(!uf.isConnected(i,j)){
                    //如果相似
                    if(isSimilar(strs[i],strs[j])){
                        uf.join(i,j);
                        //合并，并减少一个连通分量
                        ans--;
                    }
                }
            }
        }
        return ans;
    }
};

算法复杂度

时间复杂度： $O(n^{2}m\cdot \alpha (n))$ 。其中$\alpha$为反阿克曼函数，n为字符串个数，m为字符串长度。 使用按秩合并与路径压缩的并查集，在平均意义为$O(\alpha (n))$，约等于$O(1)$。由于需要遍历每对字符串，检查相似性，需要$O(\frac{n(n-1)}{2})\ast O(m)$的时间。

空间复杂度： $O(n)$ 。并查集记录父节点和秩分别需要$O(n)$的空间。

(为什么这么慢QAQ）