python图论

class UF:
    def __init__(self, n):
        self.n = n 
        self.FA = list(range(n)) 
    def getroot(self,x):
        path = []
        while x != self.FA[x]:
            path.append(x)
            x = self.FA[x]
        for w in path:
            self.FA[w] = x
        return x
    def union(self ,x, y): 
        rx,ry = self.getroot(x),self.getroot(y) 
        if rx == ry : return False 
        self.FA[rx] = ry 
        return True  
    def getgroup(self, vertexes):
        G = defaultdict(list)
        for i in vertexes:
            G[self.getroot(i)].append(i)
        return G

#下标从1开始
class UF:
    def __init__(self,n,cp=None):
        if cp: self.Fa = cp.Fa[:]
        else : self.Fa = [n] + [-1] * n  
    def getroot(self,i):
        root = i 
        while self.Fa[root] >= 0 :
            root =self.Fa[root]  
        while i != root : 
            tmp,self.Fa[i] = self.Fa[i],root 
            i = tmp  
        return root 
    def union(self,a,b):
        ra,rb = self.getroot(a),self.getroot(b)  
        if ra != rb: 
            self.Fa[0] -= 1  
            self.Fa[rb] += self.Fa[ra] 
            self.Fa[ra] = rb
            return True 
        return False  

        m , n = len(grid) , len(grid[0]) 
        def push(i,j):
            if grid[i][j] == 0 : 
                grid[i][j] = 1 
                q.append([i,j])
        res = 0 
        q = deque()
        for i in range(m):
            for j in range(n):
                if grid[i][j]: continue 
                flag = 1
                push(i,j) 
                while q :
                    x,y = q.popleft() 
                    for nx,ny in [(x,y+1),(x+1,y),(x,y-1),(x-1,y)] :
                        if not (0<=nx<m and 0<=ny<n):
                            flag = 0 
                        else: 
                            push(nx,ny) 
                res += flag 
        return res

        n = len(nums)
        time_in = [0] * n 
        time_out = [0] * n 
        G = [[] for _ in range(n+1)] 
        for a,b in edges:
            G[a].append(b)
            G[b].append(a) 
        clock = 0 
        def dfs(i,fa):
            nonlocal clock 
            clock += 1 
            time_in[i] = clock 
            for j in G[i]: 
                if j != fa : 
                    dfs(j,i) 
                    nums[i] ^= nums[j] 
            time_out[i] = clock 
        dfs(0,-1)