技術標籤：演算法leetcode

相似字串組

• 題目
• 思路
• 程式碼
• 演算法複雜度

題目來源於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 C_m^2 Cm2​種可能，之後就超時了。

更簡單的辦法就是，遍歷一次字串。找到兩個位置不同的字元【交換】，如果【字串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 ⋅ α ( n ) ) O(n^2m \cdot \alpha(n)) O(n2m⋅α(n)) 。其中 α \alpha α為反阿克曼函式，n為字串個數，m為字串長度。 使用按秩合併與路徑壓縮的並查集，在平均意義為 O ( α ( n ) ) O(\alpha(n)) O(α(n))，約等於 O ( 1 ) O(1) O(1)。由於需要遍歷每對字串，檢查相似性，需要 O ( n ( n − 1 ) 2 ) ∗ O ( m ) O({n (n-1)\over2})*O(m) O(2n(n−1)​)∗O(m)的時間。

空間複雜度： O ( n ) O(n) O(n) 。並查集記錄父節點和秩分別需要 O ( n ) O(n) O(n)的空間。

(為什麼這麼慢QAQ）