岛屿数量问题

最新推荐文章于 2024-10-08 10:36:00 发布

头发凌乱的鳌拜

最新推荐文章于 2024-10-08 10:36:00 发布

阅读量290

点赞数

分类专栏： Leetcode 文章标签： leetcode 动态规划算法

本文链接：https://blog.csdn.net/oceanicC/article/details/123019108

版权

Leetcode 专栏收录该内容

53 篇文章 0 订阅

订阅专栏

200. 岛屿数量 - 力扣（LeetCode） (leetcode-cn.com)

1.DFS解法--感染问题

每次遇到为‘1’的地方都去DFS搜索这整块岛屿，直到边界；每次遇到一块岛屿，计数器就加一

时间复杂度：O（mn)

空间复杂度：O（mn)

代码如下：

class Solution(object):
    def numIslands(self, grid):
        """
        :type grid: List[List[str]]
        :rtype: int
        """
        count=0
        for i in range(len(grid)):
            for j in range(len(grid[0])):
                if grid[i][j]=='1':
                    self.infect(grid,i,j)
                    count+=1
        return count
    def infect(self,grid,i,j):
        if i<0 or j<0 or i>=len(grid) or j >=len(grid[0]) or grid[i][j] !='1':
            return 
        grid[i][j]='2'
        self.infect(grid,i-1,j)
        self.infect(grid,i+1,j)
        self.infect(grid,i,j-1)
        self.infect(grid,i,j+1)
        return

2.BFS搜索

时间复杂度：O(mn)

空间复杂度：O(min(m,n))

class Solution(object):
    def numIslands(self, grid):
        """
        :type grid: List[List[str]]
        :rtype: int
        """
        island=0
        for i in range(len(grid)):
            for j in range(len(grid[0])):
                if grid[i][j]=='1':
                    island+=1
                    grid[i][j]='2'
                    neighbors=[]
                    neighbors.append((i,j))
                    while neighbors:
                        x,y=neighbors.pop(0)
                        for m,n in [(x-1,y),(x+1,y),(x,y-1),(x,y+1)]:
                            if 0<=m<len(grid) and 0<=n<len(grid[0]) and grid[m][n]=='1':
                                grid[m][n]='2'
                                neighbors.append((m,n))
        return island

3.并查集

遇到1则遍历邻居节点，记为一棵树，有一个parent；

统计总共有多少个parent。

class UnionFind(object):
    def __init__(self,grid):
        self.count=0
        m,n=len(grid),len(grid[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.count+=1
                    self.parent[i*n+j]=i*n+j
    def find(self,x):
        if self.parent[x]!=x:
            self.parent[x]=self.find(self.parent[x])
        return self.parent[x]
    
    def union(self,x,y):
        rootx=self.find(x)
        rooty=self.find(y)
        if rootx!=rooty:
            if self.rank[rootx]<self.rank[rooty]:
                rootx,rooty=rooty,rootx
            self.parent[rootx]=rooty
            if self.rank[rootx]==self.rank[rooty]:
                self.rank[rooty]+=1
            self.count-=1
    def getCount(self):
        return self.count




class Solution(object):
    def numIslands(self, grid):
        """
        :type grid: List[List[str]]
        :rtype: int
        """
        island=0
        uf=UnionFind(grid)
        for i in range(len(grid)):
            for j in range(len(grid[0])):
                if grid[i][j]=='1':
                    grid[i][j]='2'
                    for m,n in [(i-1,j),(i+1,j),(i,j-1),(i,j+1)]:
                        if 0<=m<len(grid) and 0<=n<len(grid[0]) and grid[m][n]=='1':
                            uf.union(m*len(grid[0])+n,i*len(grid[0])+j)
        return uf.getCount()