Python子类重写了具有不同签名的方法，所以不调用基类方法。为什么呢？ 类联合查找： 定义初始化（self，n）： self.parents=列表（范围（n）） self.ranks=[0]*n 定义查找（self，x）：#_查找->查找 如果self.parents[x]！=x: self.parents[x]=self.\u查找（self.parents[x]）\u查找->查找 返回自我。父母[x] def_接头（自、x、y）： px=self._find（x）#_find->find py=self._查找（y）#_查找->查找 如果px==py：返回False 如果self.ranks[px]

self.find（）

始终使用

find

方法，无论

self

是什么类型。如果在

UnionFind

方法中调用

self.find（..）

，但

self

是一个

孤岛

，它将调用

Island.find（）

。这是大多数面向对象语言的工作方式

如果您想专门调用

UnionFind.find

，那么您在创建一个非继承的

\u find

时做的是正确的。我甚至可能称它为

\u find

，这样它就不会被意外继承。

运行时错误类型错误：find（）缺少1个必需的位置参数：“j'px=self.find（x）inu union（Solution.py）if super（）。\u union（x，y）：union（Solution.py）中的第58行self.union（I，j，ni，nj）addIsland（Solution.py）中的第48行numIslands2（Solution.py）中的island.addIsland（i，j）第66行ret=Solution（）.numIslands2（param_1，param_2，param_3）第98行in驱动程序（Solution.py）第109行in（Solution.py）

class UnionFind:

    def __init__(self, n):
        self.parents = list(range(n))
        self.ranks = [0]*n

    def _find(self, x):  # _find -> find

        if self.parents[x] != x:
            self.parents[x] = self._find(self.parents[x])  # _find -> find

        return self.parents[x]

    def _union(self, x, y):

        px = self._find(x)  # _find -> find
        py = self._find(y)  # _find -> find

        if px == py: return False

        if self.ranks[px] < self.ranks[py]:
            py, px = px, py

        self.parents[py] = px
        if self.ranks[px] == self.ranks[py]:
            self.ranks[px] += 1
        return True

class Island(UnionFind):
    
    def __init__(self, m, n):
        super().__init__(m*n+1)
        self.m = m
        self.n = n
        self.islands = 0
        self.occupied = set()
        
    def _coordToIdx(self, i, j):
        return i*self.n+j+1;
    
    def addIsland(self, i, j):
        if (i,j) in self.occupied: return
        self.islands += 1
        self.occupied.add((i,j))
        for di, dj in [(0,1),(1,0),(0,-1),(-1,0)]:
            ni, nj = i+di, j+dj
            if 0<=ni<self.m and 0<=nj<self.n and (ni,nj) in self.occupied:
                self.union(i,j,ni,nj)
                
    def getIslands(self):
        return self.islands
    
    def find(self, i, j):
        return super().find(self._coordToIdx(i,j))
    
    def union(self, i1,j1, i2,j2):
        x, y = self._coordToIdx(i1,j1), self._coordToIdx(i2,j2)
        if super()._union(x, y):
            self.islands -= 1

class Solution:
    def numIslands2(self, m: int, n: int, positions: List[List[int]]) -> List[int]:
        ans = []
        island = Island(m,n)
        for i, j in positions:
            island.addIsland(i,j)
            ans.append(island.getIslands())
        return ans