并查集问题

并查集(Union-find or Disjoint-set)问题是一个很有趣现实中很常见的问题，也并不是一个能够无脑解决的问题。

首先贴上一个讲解详细的帖子
https://blog.csdn.net/guoziqing506/article/details/78752557

什么是并查集问题？举个例子:
有一个元素集合{A, B, C, D, E, F, G}，元素之间的关系是{AB, BC, CD, EF, FG}
我们希望将存在传递关系的元素分为一组，即得到{A, B, C, D}和{E, F, F}

1.遍历

我们的第一反应是遍历，好吧充足的时间下没有遍历解决不了的问题，
这里给出一个递归的实现,时间复杂度应该是O(n^n)吧

pointList = ['A','B','C','D','E','F','G']
linkList = [('A','B'),('B','C'),('C','D'),('E','F'),('F','G'),]
G = nx.Graph()


visted = []

def findNeighboor(v,oneSubset):
    oneSubset.append(v)
    visted.append(v)
  # 如果自己的邻居没有加入集合，就对它进行递归操作
    for link in linkList:
        if link[0]==v and link[1] not in oneSubset:
            findNeighboor(link[1],oneSubset)
        if link[1]==v and link[0] not in oneSubset:
            findNeighboor(link[0],oneSubset)
    return oneSubset

def findDisjointSet():
    allSet = []
    for point in pointList:
        if point not in visted:
            oneSubset = []
            oneSubset = findNeighboor(point,oneSubset)
            allSet.append(oneSubset.copy())
    print(allSet)
    
findDisjointSet()

2.并查集解决问题

并查集是一种树形的数据结构，参考链接
https://blog.csdn.net/doncoder/article/details/79182542
https://blog.csdn.net/fkjslee/article/details/48809903

思想如下:
初始化：每个点看做一棵树 ，并且为每个树的树根；树根就是每个组别的代表。

查询：对于点对(a,b)，通过a和b去向上查找他们的祖先节点直到树根，如果有相同的祖先节点，则他们在已经在一棵树下，属于同一组别。

合并：若不在同一组别，令其中一个点（比如a）所在树的根节点成为另一个点（比如b）的根节点的孩子。这样即便再查询到a，最终会判断认为a属于b的组别。

大树小树合并技巧: 小树变成大树的子树，会比大树变成小树的子树更加不易增加树高，这样可以减少查询次数。

压缩路径: 为了尽量减小树的的高度，我们可以在从每个节点进行回溯时，存储所有的中间节点（可以用递归实现），并且将他们的都直接指向根节点。这样树就会变得扁平，树高显著降低。这个方法因为要存储中间节点，会增加空间复杂度。所以一个备选的思路是每遍历到一个节点，就将这个节点变成他的爷爷节点的孩子（和其父节点在同一层了）。相当于是压缩了查询的路径，这样，频繁的查询当然会导致树的“扁平化”程度更彻底。

# 并查集

class TreeNode():
    def __init__(self):
        self.parent = None
        self.children = []
        self.data = None

# 初始化
def initDisjointSet(allRootSet):
    nodes = {}
    for point in pointList:
        node = TreeNode()
        node.data = point
        node.parent = node
        allRootSet[point] = [point]
        nodes[point] = node
    return nodes

# 查询
def findRoot(a):
    nodes = []
    while a.parent != a:
        nodes.append(a)
        a = a.parent
    for node in nodes:
        node.parent = a
    return a

# 查询 递归实现
def findRoot2(a):
    if a == a.parent:
        return a
    else:
        a.parent = findRoot2(a.parent)

# 合并
def union_set(a,b,allRootSet):
    fa = findRoot(a)
    fb = findRoot(b)
    # fa的根指向fb,合并两个子树
    fa.root = fb
    # 合并
    allRootSet[fb.data].extend(allRootSet[fa.data])
    # 删除一个子集代表
    allRootSet[fa.data] = None

def getDisjointSet():
    allRootSet = {}
    nodes = initDisjointSet(allRootSet)
    for link in linkList:
        union_set(nodes[link[0]],nodes[link[1]],allRootSet)
  # 打印最终结果
    print(allRootSet)

getDisjointSet()

并查集的时间复杂度分析
https://blog.csdn.net/johnny901114/article/details/80721436
我上面的实现查找需要的时间复杂度是O(h) 合并是O(1)
这里的链接证明最后的时间复杂度是O(log* n)
这个复杂度没看懂，偷个懒

更多内容可移步我的GitHub，谢谢
https://github.com/DaLiWangCC/Algorithm_study