解法

中心思想是用並查集，關鍵點是聯絡的輸入
兩種方法：

1. 列舉list裡兩兩字串之間的相系，適合詞少的時候
2. 遍歷每個字元，列舉它可能到達的字元，適合詞多的時候
   假設字串s可以到達t，注意這裡是存的是t到s的邊，因為set[i]要存i字串可以到達的在list裡的字串的集合

點：

1. 詞稀疏和稠密適合不同的演算法
2. 注意最後統計的時候同一個s不要統計2次

標準答案裡並查集用的是陣列下標，我用的是字串hash，反正也過了，懶得改了

class Solution(object):
    def numSimilarGroups(self,
 
 A):
        """
        :type A: List[str]
        :rtype: int
        """
        import itertools
        f = {}
        n = len(A)
        if n==0:
            return 0
        w = len(A[0])

        def is_similar(a,b):
            l = len(a)
            rest = 2
            for i in xrange(l):
                if
 
 a[i]!=b[i]:
                    rest -= 1
                    if rest<0:
                        return False
            return rest>=0

        def find(x):
            if x not in f:
                f[x]=x
                return x
            r = x
            while f[r]!=r:
                r =
 
 f[r]
            while x!=r:
                tmp = f[x]
                f[x] = r
                x = tmp
            return r

        def join(x,y):
            f[find(y)]=find(x)

        if n<w*w:
            for i in xrange(n-1):
                for j in xrange(i,n):
                    if is_similar(A[i],A[j]):
                        join(A[i],A[j])
        else:
            from collections import defaultdict
            edges = defaultdict(set)
            for string in A:
                L = list(string)
                for j1,j2 in itertools.combinations(xrange(w), 2):
                    L[j1], L[j2] = L[j2], L[j1]
                    edges["".join(L)].add(string)
                    L[j1], L[j2] = L[j2], L[j1]
            for string in A:
                for word in edges[string]:
                    join(string, word)
        return len(filter(lambda x:x not in f or f[x]==x, set(A)))