leetcode 并查集UnionFind（547.朋友圈）

题目描述

班上有 N 名学生。其中有些人是朋友，有些则不是。他们的友谊具有是传递性。如果已知 A 是 B 的朋友，B 是 C 的朋友，那么我们可以认为 A 也是 C 的朋友。所谓的朋友圈，是指所有朋友的集合。

给定一个 N * N 的矩阵 M，表示班级中学生之间的朋友关系。如果M[i][j] = 1，表示已知第 i 个和 j 个学生互为朋友关系，否则为不知道。你必须输出所有学生中的已知的朋友圈总数。

样例
输入：
[[1,1,0],
[1,1,0],
[0,0,1]]
输出：2
解释：已知学生 0 和学生 1 互为朋友，他们在一个朋友圈。
第2个学生自己在一个朋友圈。所以返回 2 。
输入：
[[1,1,0],
[1,1,1],
[0,1,1]]
输出：1
解释：已知学生 0 和学生 1 互为朋友，学生 1 和学生 2 互为朋友，所以学生 0 和学生 2 也是朋友，所以他们三个在一个朋友圈，返回 1 。

题解

方法一：深度优先搜索

定义一个大小为N的visited数组，visited[i]表示第i个元素是否被访问。
随机选择一个未被访问过的结点，访问任一相邻的结点。然后再访问该节点的任一相邻节点。不断遍历到未访问的相邻节点，回溯到之前的结点进行访问。
直至所有的元素都被访问过。

def findCircleNum(m):
    n = len(m)
    count = 0
    visited = set()

    def dfs(i):  #深搜
        for j in range(n):  #这里会回溯的
            if m[i][j] and j not in visited:
                visited.add(j)
                dfs(j)  # 一直往深搜
    for i in range(n):
        if i not in visited:
            count += 1
            visited.add(i)
            dfs(i)
    return count

方法二：广度优先搜索

同样定义一个大小为N的visited数组，visited[i]表示第i个元素是否被访问过。
随机选择一个未被访问过的结点，访问其所有邻接结点，然后再依次访问邻接结点的所有邻接结点。
直至所有的元素都被访问过。

def findCircleNum3(m):  #广搜
    n = len(m)
    count = 0
    visited = set()

    def bfs(i):  #广搜
        temp = [i]
        while len(temp):
            t = temp.pop()  #拿出一个当前group的元素
            for j in range(n):
                if m[t][j] and j not in visited:  # 相邻并且没有被访问过
                    temp.append(j)  #才能添加到当前group中，
                    #如果已经被访问过了，那就不必添加了，不然会死循环（确保每次添加到temp中的元素是没有访问过的）
                    visited.add(j)

    for i in range(n):
        if i not in visited:
            count += 1
            visited.add(i)
            bfs(i)
    return count

本来以为自己写不对，结果一提交，我的妈耶，写代码就是这么让人惊喜又意外的吧~太开心了！！！

方法三：并查集

终于到了并查集了……昨晚看不懂的并查集，找了个博客
并查集(Union-Find Sets)主要用于处理一些不相交集合的问题。
比如求连通图、求最小生成树的kruskal算法和求最近公共祖先等……

使用并查集时，首先会存在一组不相交的动态集合，一般都会使用一个整数表示集合中的一个元素。

每个集合可能会包含一个或多个元素，并选出集合中的某个元素作为代表。每个集合中具体包含了哪些元素是不关心的，具体选择哪个元素作为代表一般也是不关心的。我们关心的是，对于给定的元素，可以很快的找到这个元素所在的集合（的代表），以及合并两个元素所在的集合，而且这些操作的时间复杂度都是常数级的。
并查集的基本操作：

1. makeSet(s)：建立一个新的并查集，其中包含s个单元素集合。
2. unionSet(x,y)：把元素x和元素y所在的集合合并，要求x和y所在的集合不相交，如果相交则不合并。
3. find(x)：找到元素x所在的集合的代表，该操作也可以用于判断两个元素是否位于同一个集合，只要将他们各自的代表比较一下就可以了。

并查集的实现原理也比较简单，就是使用树来表示集合，树的每个结点就表示集合中的一个元素，树根对应的元素就是该集合的代表。如下图所示。

图中有两棵树，分别对应两个集合，其中第一个集合为{a,b,c,d}，代表元素为a；第二个集合为{e,f,g}，代表元素为e。
树的节点表示集合中的元素，指针表示指向父节点的指针，根结点的指针指向自己，表示其没有父节点。
沿着每个结点的父节点不断向上查找，最终就可以找到该树的根节点，即该集合的代表元素。

现在，应该可以很容易的写出makeSet和find的代码了。假设使用一个足够长的数组来存储树结点，那么makeSet要做的就是构造出如图2的森林，每个元素都是一个单元素集合，即父节点是其本身。

相应的代码如下：

        def __init__(self,size):
            self.p = [i for i in range(size + 1)]
            self.num = size

接下来，就是find操作了，如果每次都沿着父节点向上查找，那时间复杂度就是树的高度，这就达不到常数级了。这里需要应用一种简单有效的策略——路径压缩。
路径压缩，就是在每次查找时，令查找路径上的每个结点都直接指向他的代表结点（即根结点），如图3所示。

代码如下：

        def find(self,x):   #查找根结点(代表结点)
            if self.p[x] != x:
                self.p[x] = self.find(self.p[x])  #递归，不断往上找
            return self.p[x]

最后是合并操作unionSet，并查集的合并也非常简单，就是将一个集合的树根指向另一个集合的树根，如图4所示。

代码如下：

        def union(self,a,b):
            if self.find(a) != self.find(b):
                self.p[self.find(a)] = self.p[self.find(b)]
                self.num -= 1

总体代码：

def findCircleNum2(m):  #并查集
    class UnionFind(object):
        def __init__(self,size):
            self.p = [i for i in range(size + 1)]
            self.num = size
            # print(self.p)
        def find(self,x):   #查找根结点(代表结点)
            if self.p[x] != x:
                self.p[x] = self.find(self.p[x])  #递归，不断往上找
            return self.p[x]

        def union(self,a,b):
            if self.find(a) != self.find(b):
                self.p[self.find(a)] = self.p[self.find(b)]
                self.num -= 1
                # print(self.p)

    n = len(m)
    if n == 1:
        return 1
    uf = UnionFind(n)
    for i in range(n):
        for j in range(i+1,n):
            if m[i][j]:
                uf.union(i,j)
    return uf.num

这里附上另一种讲解并查集的讲法

本来我是没怎么看懂的，直到我看了这个故事……

为了解释并查集的原理，我将举一个更有爱的例子。 话说江湖上散落着各式各样的大侠，有上千个之多。他们没有什么正当职业，整天背着剑在外面走来走去，碰到和自己不是一路人的，就免不了要打一架。但大侠们有一个优点就是讲义气，绝对不打自己的朋友。而且他们信奉“朋友的朋友就是我的朋友”，只要是能通过朋友关系串联起来的，不管拐了多少个弯，都认为是自己人。这样一来，江湖上就形成了一个一个的群落，通过两两之间的朋友关系串联起来。而不在同一个群落的人，无论如何都无法通过朋友关系连起来，于是就可以放心往死了打。但是两个原本互不相识的人，如何判断是否属于一个朋友圈呢？
\quad
我们可以在每个朋友圈内推举出一个比较有名望的人，作为该圈子的代表人物，这样，每个圈子就可以这样命名“齐达内朋友之队”“罗纳尔多朋友之队”……两人只要互相对一下自己的队长是不是同一个人，就可以确定敌友关系了。
\quad
但是还有问题啊，大侠们只知道自己直接的朋友是谁，很多人压根就不认识队长，要判断自己的队长是谁，只能漫无目的的通过朋友的朋友关系问下去：“你是不是队长？你是不是队长？”这样一来，队长面子上挂不住了，而且效率太低，还有可能陷入无限循环中。于是队长下令，重新组队。队内所有人实行分等级制度，形成树状结构，我队长就是根节点，下面分别是二级队员、三级队员。每个人只要记住自己的上级是谁就行了。遇到判断敌友的时候，只要一层层向上问，直到最高层，就可以在短时间内确定队长是谁了。由于我们关心的只是两个人之间是否连通，至于他们是如何连通的，以及每个圈子内部的结构是怎样的，甚至队长是谁，并不重要。所以我们可以放任队长随意重新组队，只要不搞错敌友关系就好了。于是，门派产生了。

下面我们来看并查集的实现。 int pre[1000]; 这个数组，记录了每个大侠的上级是谁。大侠们从1或者0开始编号（依据题意而定），pre[15]=3就表示15号大侠的上级是3号大侠。如果一个人的上级就是他自己，那说明他就是掌门人了，查找到此为止。也有孤家寡人自成一派的，比如欧阳锋，那么他的上级就是他自己。每个人都只认自己的上级。比如胡青牛同学只知道自己的上级是杨左使。张无忌是谁？不认识！要想知道自己的掌门是谁，只能一级级查上去。 find这个函数就是找掌门用的，意义再清楚不过了（路径压缩算法先不论，后面再说）。

int find(int x)                                                                  //查找我（x）的掌门
{
    int r=x;                                   //委托 r 去找掌门
    while (pre[r ]!=r)                         //如果r的上级不是r自己（也就是说找到的大侠他不是掌门 = =）
    r=pre[r ] ;                                // r 就接着找他的上级，直到找到掌门为止。
    return  r ;                                //掌门驾到~~~
}

再来看看join函数，就是在两个点之间连一条线，这样一来，原先它们所在的两个板块的所有点就都可以互通了。这在图上很好办，画条线就行了。但我们现在是用并查集来描述武林中的状况的，一共只有一个pre[]数组，该如何实现呢？ 还是举江湖的例子，假设现在武林中的形势如图所示。虚竹小和尚与周芷若MM是我非常喜欢的两个人物，他们的终极boss分别是玄慈方丈和灭绝师太，那明显就是两个阵营了。我不希望他们互相打架，就对他俩说：“你们两位拉拉勾，做好朋友吧。”他们看在我的面子上，同意了。这一同意可非同小可，整个少林和峨眉派的人就不能打架了。这么重大的变化，可如何实现呀，要改动多少地方？其实非常简单，我对玄慈方丈说：“大师，麻烦你把你的上级改为灭绝师太吧。这样一来，两派原先的所有人员的终极boss都是师太，那还打个球啊！反正我们关心的只是连通性，门派内部的结构不要紧的。”玄慈一听肯定火大了：“我靠，凭什么是我变成她手下呀，怎么不反过来？我抗议！”抗议无效，上天安排的，最大。反正谁加入谁效果是一样的，我就随手指定了一个。这段函数的意思很明白了吧？

void join(int x,int y)                                //我想让虚竹和周芷若做朋友
{
    int fx=find(x),fy=find(y);                        //虚竹的老大是玄慈，芷若MM的老大是灭绝
    if(fx!=fy)                                        //玄慈和灭绝显然不是同一个人
    pre[fx ]=fy;                                      //方丈只好委委屈屈地当了师太的手下啦
}