[Swift]LeetCode839. 相似字符串组 | Similar String Groups

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址： https://www.cnblogs.com/strengthen/p/10579363.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

Two strings X and Y are similar if we can swap two letters (in different positions) of X, so that it equals Y.

For example, "tars" and "rats" are similar (swapping at positions 0 and 2), and "rats" and "arts" are similar, but "star" is not similar to "tars", "rats", or "arts".

Together, these form two connected groups by similarity: {"tars", "rats", "arts"} and {"star"}.  Notice that "tars" and "arts" are in the same group even though they are not similar.  Formally, each group is such that a word is in the group if and only if it is similar to at least one other word in the group.

We are given a list A of strings.  Every string in A is an anagram of every other string in A.  How many groups are there?

Example 1:

Input: ["tars","rats","arts","star"]
Output: 2

Note:

1. A.length <= 2000
2. A[i].length <= 1000
3. A.length * A[i].length <= 20000
4. All words in A consist of lowercase letters only.
5. All words in A have the same length and are anagrams of each other.
6. The judging time limit has been increased for this question.

---

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

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

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

我们给出了一个不包含重复的字符串列表 A。列表中的每个字符串都是 A 中其它所有字符串的一个字母异位词。请问 A 中有多少个相似字符串组？

示例：

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

提示：

1. A.length <= 2000
2. A[i].length <= 1000
3. A.length * A[i].length <= 20000
4. A 中的所有单词都只包含小写字母。
5. A 中的所有单词都具有相同的长度，且是彼此的字母异位词。
6. 此问题的判断限制时间已经延长。

备注：

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

---

Time Limit Exceeded

class Solution {
    func numSimilarGroups(_ A: [String]) -> Int {
        var A = A
        if A.isEmpty {return 0}
        if A[0].count < 20 {return help2(&A)}
        else{ return help1(&A)}
    }
    
    func check(_ str1:String,_ str2:String) -> Bool
    {
        let len:Int = str1.count
        var cnt:Int = 0
        var arr1:[Character] = Array(str1)
        var arr2:[Character] = Array(str2)
        for i in 0..<len
        {
            if arr1[i] != arr2[i]
            {
                cnt += 1
                if cnt > 2
                {
                    return false
                }
            }
        }
        return true
    }
    
    func find(_ x:Int,_ p:inout [Int]) -> Int
    {
        if x != p[x]
        {
            p[x] = find(p[x],&p)
        }
        return p[x]
    }
    
    func help1(_ A:inout [String]) -> Int
    {
        let n:Int = A.count
        var fa:[Int] = [Int]()
        for i in 0..<n
        {
            fa.append(i)
        }
        for  i in 0..<n
        {
            for j in (i + 1)..<n
            {
                if check(A[i] ,A[j])
                {
                    let num:Int = find(i,&fa)
                    fa[num] = find(j,&fa)
                }
            }
        }
        var ans:Int = 0
        for i in 0..<fa.count
        {
            if fa[i] == i
            {
                ans += 1
            }
        }
        return ans
    }
    
    func help2(_ A:inout [String]) -> Int
    {
        var sA:Set<String> = Set(A)
        var q:[String] = [String]()
        var n:Int = 0
        while(!sA.isEmpty)
        {
            q.append(sA.removeFirst())
            n += 1
            while(!q.isEmpty)
            {
                var s:String = q.first!
                q.removeFirst()
                let len:Int = s.count      
                var arr:[Character] = Array(s)
                for i in 0..<len
                {                 
                    for j in (i + 1)..<len
                    {
                        if arr[i] != arr[j]
                        {
                            var arrS = arr
                            arrS.swapAt(i, j)
                            let str:String = String(arrS)
                            if sA.contains(str)
                            {
                                q.append(str)
                                sA.remove(str)
                            }
                            if sA.isEmpty {return n}
                        }
                    }
                }
            }
        }
        return n
    }
}

---

 Time Limit Exceeded

class Solution {
    func numSimilarGroups(_ A: [String]) -> Int {
        var A = A
        var countA:Int = A.count
        if countA < 2 {return countA}
        var res:Int = 0
        for i in 0..<countA
        {
            if A[i].isEmpty {continue}
            var str:String = A[i]
            A[i] = String()
            res += 1
            dfs(&A,str)
        }
        return res
    }
    
    func dfs(_ arr:inout [String],_ str:String)
    {
        for i in 0..<arr.count
        {
            if arr[i].isEmpty {continue}
            if helper(str,arr[i])
            {
                var s:String = arr[i]
                arr[i] = String()
                dfs(&arr,s)
            }
        }
    }

    func helper(_ s:String,_ t:String) -> Bool
    {
        var arrS:[Character] = Array(s)
        var arrT:[Character] = Array(t)
        var res:Int = 0
        var i:Int = 0
        while(res <= 2 && i < s.count)
        {
            if arrS[i] != arrT[i]
            {
                res += 1
            }
            i += 1
        }
        return res == 2
    }
}

    

---

Time Limit Exceeded

class Solution {
    func numSimilarGroups(_ A: [String]) -> Int {
        var uf:UnionFind = UnionFind(A.count)
        let countA:Int = A.count
        for i in 0..<countA
        {
            for j in (i + 1)..<countA
            {                
                if isSimilar(A[i], A[j])
                {
                    uf.union(i,j)
                }
            }
        }
        return uf.getSize()
    }

    func isSimilar(_ a:String,_ b:String) -> Bool
    {
        var arrA:[Character] = Array(a)
        var arrB:[Character] = Array(b)
        var count:Int = 0
        var num:Int = arrA.count > arrB.count ? arrA.count : arrB.count
        for i in 0..<num
        {            
            if arrA[i] != arrB[i] && ++count > 2
            {
                return false
            }
        }
        return true
    }
}

/*扩展Int类，实现自增++运算符*/
extension Int{
    //++前缀:先自增再执行表达示
    static prefix func ++(num:inout Int) -> Int {
        //输入输出参数num
        num += 1
        //返回加1后的数值
        return num
    }
}

class UnionFind
{
    var sets:[Int]
    var size:Int

    init(_ size:Int)
    {
        self.sets = [Int](repeating:0,count:size)
        self.size = size
        for i in 0..<size
        {
            sets[i] = i
        }
    }

    func union(_ i:Int,_ j:Int)
    {
        var u:Int = find(sets, i)
        var v:Int = find(sets, j)
        if(u != v){
            sets[u] = v
            size -= 1
        }
    }

    func find(_ sets:[Int],_ v:Int) -> Int
    {
        return sets[v] == v ? v : find(sets, sets[sets[v]])
    }    

    func getSize() -> Int
    {
        return size
    }
}