leetcode-200-岛屿数量

题目描述：

 方法一：dfs

class Solution:
    def numIslands(self, grid: List[List[str]]) -> int:
        def dfs(grid,r,c):
            nr = len(grid)
            nc = len(grid[0])
            if   r<0 or c<0 or r==nr or c==nc or grid[r][c]=='0':
                return
            grid[r][c] = '0'
            dfs(grid,r-1,c)
            dfs(grid,r+1,c)
            dfs(grid,r,c-1)
            dfs(grid,r,c+1)
        if not grid:
            return 0
        nr = len(grid)
        nc = len(grid[0])
        num = 0
        for i in range(nr):
            for j in range(nc):
                if grid[i][j]=='1':
                    num += 1
                    dfs(grid,i,j)
        return num

另：

class Solution:
    def numIslands(self, grid: List[List[str]]) -> int:
        def dfs(grid,r,c,marked):
            marked[r][c] = True
            nr = len(grid)
            nc = len(grid[0])
            for d in directions:  
                new_r = r + d[0]
                new_c = c + d[1]
                if 0 <= new_r < nr and 0 <= new_c < nc and not marked[new_r][new_c] and grid[new_r][new_c] == '1': 
                    dfs(grid, new_r, new_c, marked)

        if not grid:
            return 0
        nr = len(grid)
        nc = len(grid[0])
        num = 0
        directions = [(-1, 0), (0, -1), (1, 0), (0, 1)]
        marked = [[False for _ in range(nc)]for _ in range(nr)]
        for i in range(nr):
            for j in range(nc):
                if not marked[i][j] and grid[i][j]=='1':
                    num += 1
                    dfs(grid,i,j,marked)
        return num

方法二：bfs

from collections import deque
class Solution:
    def numIslands(self, grid: List[List[str]]) -> int:
        if not grid:
            return 0
        nr = len(grid)
        nc = len(grid[0])
        num = 0
        directions = [(-1, 0), (0, -1), (1, 0), (0, 1)]
        marked = [[False for _ in range(nc)]for _ in range(nr)]
        for i in range(nr):
            for j in range(nc):
                if not marked[i][j] and grid[i][j]=='1':
                    num += 1
                    queue = deque()
                    queue.append((i,j))
                    marked[i][j] = True
                    while queue:
                        r,c = queue.popleft()
                        for d in directions:  
                            new_r = r + d[0]
                            new_c = c + d[1]
                            if 0 <= new_r < nr and 0 <= new_c < nc and not marked[new_r][new_c] and grid[new_r][new_c] == '1': 
                                queue.append((new_r,new_c))
                                marked[new_r][new_c] = True

        return num

方法三：并查集

class Solution:
    def findroot_withcom(self,par,x): 
        r=x 
        while par[r]!=r: 
            par[r]=par[par[r]] 
            r=par[r] 
        return par,r

    def numIslands(self, grid: List[List[str]]) -> int:
        if not grid:
            return 0
        nr = len(grid)
        nc = len(grid[0])
        par = {}
        for i in range(nr):
            for j in range(nc):
                if grid[i][j]=='1':
                    if (i-1,j) not in par: 
                        if (i,j-1) not in par: 
                            par[(i,j)]=(i,j) 
                        else: 
                            par[(i,j)]=par[(i,j-1)] 
                    else: 
                        if (i,j-1) not in par: 
                            par[(i,j)]=par[(i-1,j)] 
                        else: 
                            par[(i,j)]=par[(i-1,j)] 
                            par,x=self.findroot_withcom(par,(i,j-1)) 
                            par[x]=par[(i-1,j)]
        roots=[] 
        res=0 #最后数数一共几个不同的根 
        for x in par: 
            par,y=self.findroot_withcom(par,x) 
            if y not in roots:
                roots.append(y) 
                res+=1 
        return res

 

---恢复内容结束---