并查集Python版
以下来自于leetcode
使用数据结构：并查集
- 思路：由于相等关系具有传递性，所有相等的变量属于同一个集合；
- 只关心连通性，不关心距离，因此很容易想到并查集。（很容易嘛，反正我想不到）
并查集
- 「并查集」用于判断一对元素是否相连，它们的关系式动态添加的，这一类问题叫做「动态连通性」问题；
- 主要支持「合并」与「查询是否在同一个集合」操作；
- 底层结构是「数组」或者「哈希表」，用于表示「节点」指向「父节点」，初始化时指向自己；
- 「合并」就是把一个集合的根节点指向另一个集合的根节点，只要根节点一样，就表示在同一个集合里；
- 这种表示「不相交集合」的方法称之为「代表元法」，以每个结点的根节点作为一个集合的「代表元」。
- 「路径压缩」和「按秩压缩」一起使用的时候，难以维护「秩」准确的定义，但依然具有参考价值。
- 同时使用「路径压缩」和「按秩合并」，
「合并」与「查询」的时间复杂度接近O(1)； - 「并查集」的时间复杂度分析，可以在互联网上搜索相关资料学习；
- 一般而言，「路径压缩」和「按秩合并」使用其中一个即可。
并查集的应用
- 最小生成树：Kruskal算法
并查集的优化1：路径压缩(Path Compression)
并查集的优化2：按「秩」(Rank)合并
- 「按秩合并」是指在合并的过程中，使得「高度」更低的树的根节点指向「高度」更高的根节点，以避免合并以后的树高度增加；
990.等式方程的可满足性。
以下来自于算法视频笔记
并查集(union & find)是一种树型的数据结构，用于处理一些不交集(Disjoint Sets)的合并及查询问题。
Find：确定元素属于哪一个子集。它可以被用来确定两个元素是否属于同一子集。
Union：将两个子集合并成同一个集合。
在生活中的例子
- 小弟——>老大
- 帮派识别
- 两种优化方式
初始化
并查集原始版代码
class baseUnion:
# n为节点大小
def __init__(self, n):
self.parent = list(range(n)) # 从0开始
# 查找(递归)
def recursion_find(self, index):
if self.parent[index] != index:
self.parent[index] = self.find(self.parent[index])
return self.parent[index]
# 查找(迭代,效率更高)
def iteration_find(self, index):
root = index
while root != self.parent[root]:
root = self.parent[root]
return self.parent[root] # 或者返回root
# 连接
def union(self, index1, index2):
self.parent[self.iteration_find(index1)] = self.recursion_find(index2)
并查集优化一
class rank_union:
# n为节点大小
def __init__(self, n):
self.parent = list(range(n)) # 从0开始
self.rank = [0] * n
# 查找和基本并查集不变
# 查找(迭代,递归也可以)
def find(self, index):
root = index
while root != self.parent[root]:
root = self.parent[root]
return self.parent[root] # 或者返回root
# 连接
def union(self, index1, index2):
rootx = self.find(index1)
rooty = self.find(index2)
# 如果不在同一连通分量里进行连接
if rootx != rooty:
if self.rank[rootx] > self.rank[rooty]:
self.parent[rooty] = rootx
elif self.rank[rootx] < self.rank[rooty]:
self.parent[rootx] = rooty
else: # 随便选一个
self.parent[rooty] = rootx
self.rank[rootx] += 1
并查集优化二
优化二效率更高，直接指向根节点，不需要添加rank属性。
# 效率更高，不需要添加rank属性(实际情况不明显)
class path_compression_union:
# n为节点大小
def __init__(self, n):
self.parent = list(range(n)) # 从0开始
self.rank = [0] * n
# 查找和基本并查集不变
# 查找(迭代,递归也可以)
def find(self, index):
root = index
while root != self.parent[root]: # 找根节点
root = self.parent[root]
while index != self.parent[index]: # 路径压缩
tmp = self.parent[index]
self.parent[index] = root
index = tmp
return self.parent[root] # 或者返回root
# 连接
def union(self, index1, index2):
self.parent[self.find(index1)] = self.find(index2)
实战题目
- number-of-islands
- friend-circles
岛屿个数
方法一：染色问题(FloodFill)
A.遍历节点：
if node == '1':
count++;
将node和附近节点->'0'; # DFS BFS
else:
不管;
具体代码:
class Solution(object):
self.dx = [-1,1,0,0]
self.dy = [0,0,-1,1]
def numIslands(self,grid):
if not grid or not grid[0]: return 0
self.max_x = len(grid); self.max_y = len(grid[0]); self.grid = grid;
self.visited = set()
return sum([self.floodfill_DFS(i,j) for i in range(self.max_x) for j in range(self.max_y)])
def floodfill_DFS(self,x,y):
if not self._is_valid(x,y):
return 0
self.visited.add((x,y))
for k in range(4):
self.floodfill_DFS(x + dx[k],y + dy[k])
return 1
def floodfill_BFS(self,x,y):
if not self._is_valid(x,y):
return 0
self.visited.add((x,y))
queue = collections.deque()
queue.append((x,y))
while queue:
cur_x,cur_y = queue.popleft()
for i in range(4):
new_x,new_y = cur_x + dx[i],cur_y + dy[i]
if self._is_valid((new_x,new_y))
self.visited.add((new_x,new_y))
queue.append((new_x,new_y))
return 1
def _is_valid(self,x,y):
if x < 0 or x >= self.max_x or y < 0 or y >= self.max_y:
return False
if self.grid[x][y] == '0' or ((x,y) in self.visited):
return False
return True
方法二：并查集
A.初始化：针对’1’结点
B.遍历所有节点，相邻节点合并；'1’合并，'0’不管
C.遍历(找不同的parents,可以在第二步进行统计)
class UnionFind(object):
def __init__(self,grid):
m,n = len(grid),len(grid[0])
self.count = 0
self.parent = [-1] *(m+n)
self.rank = [0] * (m+n)
for i in range(m):
for j in range(n):
if grid[i][j] == '1':
self.parent[i*n + j] = i*n + j # 二维坐标转为一维
self.count += 1 # 初始化加一
def find(self,i): # 递归
if self.parent[i] != i:
self.parent[i] = self.find(self.parent[i])
return self.parent[i]
def union(self,x,y):
rootx = self.find(x)
rooty = self.find(y)
if rootx != rooty:
if self.rank[rootx] > self.rank[rooty]:
self.parent[rooty] = rootx
elif self.rank[rootx] < self.rank[rooty]:
self.parent[rootx] = rooty
else:
self.parent[rooty] = rootx
self.rank[rootx] += 1
self.count -= 1 # 合并减一
class Solution(object):
def numIslands(self,grid):
if not grid or not grid[0]:
return 0
uf = UnionFind(grid)
directions = [(0,1),(0,-1),(-1,0),(1,0)]
m,n = len(grid),len(grid[0])
for i in range(m):
for j in range(n):
if grid[i][j] == '0':
continue
for d in directions:
nr,nc = i + d[0],j + d[1]
if nr >= 0 and nc >= 0 and nr < m and nc < n and grid[nr][nc] == '1':
uf.union(i*n+j,nr*n+nc)
return uf.count
朋友圈
可以转化为岛屿问题