图论之岛屿系列

news2025/2/25 5:46:29

图论之岛屿系列

形成模板进行学习，加快学习效率

深度优先遍历

# 可以直接改原始grid的采用直接改的方案来完成修改，减少了内存开支
def dfs(self, grid, i, j):
	if i < 0 or j < 0 or i >= len(grid) or j >= len(grid[0]) or grid[i][j] == "0": # 过滤条件
           return
       grid[i][j] = "0" # 写变换条件
       self.dfs(grid, i - 1, j)
       self.dfs(grid, i + 1, j)
       self.dfs(grid, i, j - 1)
       self.dfs(grid, i, j + 1)
       return

# 无法改原始grid，需要visible辅助
def dfs(self, grid, visible, i, j):
    if (
        i < 0
        or j < 0
        or i >= len(grid)
        or j >= len(grid[0])
        or grid[i][j] == "0"
        or visible[i][j]
    ):
        return
    visible[i][j] = True
    self.dfs(grid, visible, i - 1, j)
    self.dfs(grid, visible, i + 1, j)
    self.dfs(grid, visible, i, j - 1)
    self.dfs(grid, visible, i, j + 1)
    return

广度优先遍历

# 原有grid进行处理
def bfs(self, grid, i, j):
    queue = deque([[i, j]])
    grid[i][j] = "0"

    while queue:
        cur_x, cur_y = queue.pop()
        if cur_x - 1 >= 0 and grid[cur_x - 1][cur_y] == "1":
            queue.append([cur_x - 1, cur_y])
            grid[cur_x - 1][cur_y] = "0"
        if cur_x + 1 < len(grid) and grid[cur_x + 1][cur_y] == "1":
            queue.append([cur_x + 1, cur_y])
            grid[cur_x + 1][cur_y] = "0"
        if cur_y - 1 >= 0 and grid[cur_x][cur_y - 1] == "1":
            queue.append([cur_x, cur_y - 1])
            grid[cur_x][cur_y - 1] = "0"
        if cur_y + 1 < len(grid[0]) and grid[cur_x][cur_y + 1] == "1":
            queue.append([cur_x, cur_y + 1])
            grid[cur_x][cur_y + 1] = "0"
    return

# 提供辅助visible进行处理
def bfs(self, grid, nums, i, j):
	queue = deque([[i, j]])
	nums.add((i, j))
	
	while queue:
	    cur_x, cur_y = queue.pop()
	    if (
	        cur_x - 1 >= 0
	        and grid[cur_x - 1][cur_y] >= grid[cur_x][cur_y]
	        and (cur_x - 1, cur_y) not in nums
	    ):
	        queue.append([cur_x - 1, cur_y])
	        nums.add((cur_x - 1, cur_y))
	    if (
	        cur_x + 1 < len(grid)
	        and grid[cur_x + 1][cur_y] >= grid[cur_x][cur_y]
	        and (cur_x + 1, cur_y) not in nums
	    ):
	        queue.append([cur_x + 1, cur_y])
	        nums.add((cur_x + 1, cur_y))
	    if (
	        cur_y - 1 >= 0
	        and grid[cur_x][cur_y - 1] >= grid[cur_x][cur_y]
	        and (cur_x, cur_y - 1) not in nums
	    ):
	        queue.append([cur_x, cur_y - 1])
	        nums.add((cur_x, cur_y - 1))
	    if (
	        cur_y + 1 < len(grid[0])
	        and grid[cur_x][cur_y + 1] >= grid[cur_x][cur_y]
	        and (cur_x, cur_y + 1) not in nums
	    ):
	        queue.append([cur_x, cur_y + 1])
	        nums.add((cur_x, cur_y + 1))
	return

实例

岛屿数量题目描述：

给定一个由 1（陆地）和 0（水）组成的矩阵，你需要计算岛屿的数量。岛屿由水平方向或垂直方向上相邻的陆地连接而成，并且四周都是水域。你可以假设矩阵外均被水包围。

输入描述：

第一行包含两个整数 N, M，表示矩阵的行数和列数。

后续 N 行，每行包含 M 个数字，数字为 1 或者 0。

输出描述：

输出一个整数，表示岛屿的数量。如果不存在岛屿，则输出 0。

输入示例：

4 5
1 1 0 0 0
1 1 0 0 0
0 0 1 0 0
0 0 0 1 1

输出示例：

3

在这里插入图片描述
实现方案
将遍历过的grid设置为0

  1. 深度优先遍历
class Solution:
    def dfs(self, grid, i, j):
        if i < 0 or j < 0 or i >= len(grid) or j >= len(grid[0]) or grid[i][j] == "0":
            return
        grid[i][j] = "0"
        self.dfs(grid, i - 1, j)
        self.dfs(grid, i + 1, j)
        self.dfs(grid, i, j - 1)
        self.dfs(grid, i, j + 1)
        return

    def numIslands(self, grid: List[List[str]]) -> int:
        m, n = len(grid), len(grid[0])
        cnt = 0

        for i, j in product(range(m), range(n)):
            if grid[i][j] == "1":
                self.dfs(grid, i, j)
                cnt += 1
        return cnt
  1. 广度优先遍历
class Solution:
    def bfs(self, grid, i, j):
        queue = deque([[i, j]])
        grid[i][j] = "0"

        while queue:
            cur_x, cur_y = queue.pop()
            if cur_x - 1 >= 0 and grid[cur_x - 1][cur_y] == "1":
                queue.append([cur_x - 1, cur_y])
                grid[cur_x - 1][cur_y] = "0"
            if cur_x + 1 < len(grid) and grid[cur_x + 1][cur_y] == "1":
                queue.append([cur_x + 1, cur_y])
                grid[cur_x + 1][cur_y] = "0"
            if cur_y - 1 >= 0 and grid[cur_x][cur_y - 1] == "1":
                queue.append([cur_x, cur_y - 1])
                grid[cur_x][cur_y - 1] = "0"
            if cur_y + 1 < len(grid[0]) and grid[cur_x][cur_y + 1] == "1":
                queue.append([cur_x, cur_y + 1])
                grid[cur_x][cur_y + 1] = "0"
        return

    def numIslands(self, grid: List[List[str]]) -> int:
        m, n = len(grid), len(grid[0])
        cnt = 0

        for i, j in product(range(m), range(n)):
            if grid[i][j] == "1":
                self.bfs(grid, i, j)
                cnt += 1
        return cnt

岛屿的最大面积

题目描述

给定一个由 1（陆地）和 0（水）组成的矩阵，计算岛屿的最大面积。岛屿面积的计算方式为组成岛屿的陆地的总数。岛屿由水平方向或垂直方向上相邻的陆地连接而成，并且四周都是水域。你可以假设矩阵外均被水包围。

输入描述

第一行包含两个整数 N, M，表示矩阵的行数和列数。后续 N 行，每行包含 M 个数字，数字为 1 或者 0，表示岛屿的单元格。

输出描述

输出一个整数，表示岛屿的最大面积。如果不存在岛屿，则输出 0。

输入示例

4 5
1 1 0 0 0
1 1 0 0 0
0 0 1 0 0
0 0 0 1 1

输出示例

4

提示信息
在这里插入图片描述
样例输入中，岛屿的最大面积为 4。

数据范围：

方案：
与岛屿数量一致，增加一个计数功能即可

  1. 深度优先遍历
class Solution:
    def dfs(self, grid, i, j):
        if i < 0 or j < 0 or i >= len(grid) or j >= len(grid[0]) or grid[i][j] == 0:
            return
        self.cnt += 1
        grid[i][j] = 0
        self.dfs(grid, i - 1, j)
        self.dfs(grid, i + 1, j)
        self.dfs(grid, i, j - 1)
        self.dfs(grid, i, j + 1)
        return

    def maxAreaOfIsland(self, grid: List[List[int]]) -> int:
        maxN = 0
        m, n = len(grid), len(grid[0])


        for i, j in product(range(m), range(n)):
            if grid[i][j] == 1:
                self.cnt = 0
                self.dfs(grid, i, j)
                maxN = max(maxN, self.cnt)
        return maxN
  1. 广度优先遍历
class Solution:
    def bfs(self, grid, i, j):
        queue = deque([[i, j]])
        grid[i][j] = 0
        cnt = 1

        while queue:
            cur_x, cur_y = queue.pop()
            if cur_x - 1 >= 0 and grid[cur_x - 1][cur_y] == 1:
                queue.append([cur_x - 1, cur_y])
                grid[cur_x - 1][cur_y] = 0
                cnt += 1
            if cur_x + 1 < len(grid) and grid[cur_x + 1][cur_y] == 1:
                queue.append([cur_x + 1, cur_y])
                grid[cur_x + 1][cur_y] = 0
                cnt += 1
            if cur_y - 1 >= 0 and grid[cur_x][cur_y - 1] == 1:
                queue.append([cur_x, cur_y - 1])
                grid[cur_x][cur_y - 1] = 0
                cnt += 1
            if cur_y + 1 < len(grid[0]) and grid[cur_x][cur_y + 1] == 1:
                queue.append([cur_x, cur_y + 1])
                grid[cur_x][cur_y + 1] = 0
                cnt += 1
        return cnt

    def maxAreaOfIsland(self, grid: List[List[int]]) -> int:
        maxN = 0
        m, n = len(grid), len(grid[0])

        for i, j in product(range(m), range(n)):
            if grid[i][j] == 1:
                cnt = self.bfs(grid, i, j)
                maxN = max(maxN, cnt)
        return maxN

孤岛的总面积

题目描述

给定一个由 1（陆地）和 0（水）组成的矩阵，岛屿指的是由水平或垂直方向上相邻的陆地单元格组成的区域，且完全被水域单元格包围。孤岛是那些位于矩阵内部、所有单元格都不接触边缘的岛屿。

现在你需要计算所有孤岛的总面积，岛屿面积的计算方式为组成岛屿的陆地的总数。

输入描述

第一行包含两个整数 N, M，表示矩阵的行数和列数。之后 N 行，每行包含 M 个数字，数字为 1 或者 0。

输出描述

输出一个整数，表示所有孤岛的总面积，如果不存在孤岛，则输出 0。

输入示例

4 5
1 1 0 0 0
1 1 0 0 0
0 0 1 0 0
0 0 0 1 1

输出示例：

1

提示信息：
在这里插入图片描述
解题思路：
反方向法，求孤岛，只需要把不是孤岛的给变成海即可，剩下的都是孤岛，不是孤岛的需要从上下左右边界进行海化

  1. 深度优先遍历
class Solution:

    def dfs(self, grid, i, j):
        if i < 0 or j < 0 or i >= len(grid) or j >= len(grid[0]) or grid[i][j] == 0:
            return
        grid[i][j] = 0
        self.dfs(grid, i - 1, j)
        self.dfs(grid, i + 1, j)
        self.dfs(grid, i, j - 1)
        self.dfs(grid, i, j + 1)

    def SumAreaIsolatedLand(self, grid):
        m, n = len(grid), len(grid[0])
        sumN = 0

        for j in [0, -1]:
            for i in range(m):
                if grid[i][j] == 1:
                    self.dfs(grid, i, j)

        for i in [0, -1]:
            for j in range(1, n - 1):
                if grid[i][j] == 1:
                    self.dfs(grid, i, j)

        for i, j in product(range(1, m - 1), range(1, n - 1)):
            if grid[i][j] == 1:
                sumN += 1
        return sumN
  1. 广度优先遍历
class Solution:

    def bfs(self, grid, i, j):
        queue = deque([[i, j]])
        grid[i][j] = 0

        while queue:
            cur_x, cur_y = queue.pop()
            if cur_x - 1 >= 0 and grid[cur_x - 1][cur_y] == 1:
                queue.append([cur_x - 1, cur_y])
                grid[cur_x - 1][cur_y] = 0
            if cur_x + 1 < len(grid) and grid[cur_x + 1][cur_y] == 1:
                queue.append([cur_x + 1, cur_y])
                grid[cur_x + 1][cur_y] = 0
            if cur_y - 1 >= 0 and grid[cur_x][cur_y - 1] == 1:
                queue.append([cur_x, cur_y - 1])
                grid[cur_x][cur_y - 1] = 0
            if cur_y + 1 < len(grid[0]) and grid[cur_x][cur_y + 1] == 1:
                queue.append([cur_x, cur_y + 1])
                grid[cur_x][cur_y + 1] = 0
        return

    def SumAreaIsolatedLand(self, grid):
        m, n = len(grid), len(grid[0])
        sumN = 0

        for j in [0, -1]:
            for i in range(m):
                if grid[i][j] == 1:
                    self.bfs(grid, i, j)

        for i in [0, -1]:
            for j in range(1, n - 1):
                if grid[i][j] == 1:
                    self.bfs(grid, i, j)

        for i, j in product(range(1, m - 1), range(1, n - 1)):
            if grid[i][j] == 1:
                sumN += 1
        return sumN

沉没孤岛

题目描述：

给定一个由 1（陆地）和 0（水）组成的矩阵，岛屿指的是由水平或垂直方向上相邻的陆地单元格组成的区域，且完全被水域单元格包围。孤岛是那些位于矩阵内部、所有单元格都不接触边缘的岛屿。

现在你需要将所有孤岛“沉没”，即将孤岛中的所有陆地单元格（1）转变为水域单元格（0）。

输入描述：

第一行包含两个整数 N, M，表示矩阵的行数和列数。

之后 N 行，每行包含 M 个数字，数字为 1 或者 0，表示岛屿的单元格。

输出描述

输出将孤岛“沉没”之后的岛屿矩阵。

输入示例：

4 5
1 1 0 0 0
1 1 0 0 0
0 0 1 0 0
0 0 0 1 1

输出示例

1 1 0 0 0
1 1 0 0 0
0 0 0 0 0
0 0 0 1 1

提示信息
在这里插入图片描述
方案：
与孤岛总面不同的是，需要在原有grid上进行操作，不可以直接对grid进行调整，增加visible来控制非孤岛的位置，最后遍历，仍然为1的便是孤岛

  1. 深度优先遍历
class Solution:
    def dfs(self, grid, visible, i, j):
        if (
            i < 0
            or j < 0
            or i >= len(grid)
            or j >= len(grid[0])
            or grid[i][j] == 0
            or visible[i][j] is True
        ):
            return
        visible[i][j] = True
        self.dfs(grid, visible, i - 1, j)
        self.dfs(grid, visible, i + 1, j)
        self.dfs(grid, visible, i, j - 1)
        self.dfs(grid, visible, i, j + 1)
        return

    def DownIsolatedLand(self, grid):
        m, n = len(grid), len(grid[0])

        visible = [[False] * n for _ in range(m)]

        for i in [0, -1]:
            for j in range(1, n - 1):
                if grid[i][j] == 1:
                    self.dfs(grid, visible, i, j)

        for j in [0, -1]:
            for i in range(1, m - 1):
                if grid[i][j] == 1:
                    self.dfs(grid, visible, i, j)

        for i, j in product(range(1, m - 1), range(1, n - 1)):
            if grid[i][j] == 1 and visible[i][j] is False:
                grid[i][j] = 0
        return
  1. 广度优先遍历
class Solution:
    def bfs(self, grid, visible, i, j):
        queue = deque([[i, j]])
        visible[i][j] = True

        while queue:
            cur_x, cur_y = queue.pop()
            if (
                cur_x - 1 >= 0
                and grid[cur_x - 1][cur_y] == 1
                and visible[cur_x - 1][cur_y] is False
            ):
                queue.append([cur_x - 1, cur_y])
                visible[cur_x - 1][cur_y] = True
            if (
                cur_x + 1 < len(grid)
                and grid[cur_x + 1][cur_y] == 1
                and visible[cur_x + 1][cur_y] is False
            ):
                queue.append([cur_x + 1, cur_y])
                visible[cur_x + 1][cur_y] = True
            if (
                cur_y - 1 >= 0
                and grid[cur_x][cur_y - 1] == 1
                and visible[cur_x][cur_y - 1] is False
            ):
                queue.append([cur_x, cur_y - 1])
                visible[cur_x][cur_y - 1] = True
            if (
                cur_y + 1 < len(grid[0])
                and grid[cur_x][cur_y + 1] == 1
                and visible[cur_x][cur_y + 1] is False
            ):
                queue.append([cur_x, cur_y + 1])
                visible[cur_x][cur_y + 1] = True
        return

    def DownIsolatedLand(self, grid):
        m, n = len(grid), len(grid[0])

        visible = [[False] * n for _ in range(m)]

        for i in [0, -1]:
            for j in range(1, n - 1):
                if grid[i][j] == 1:
                    self.bfs(grid, visible, i, j)

        for j in [0, -1]:
            for i in range(1, m - 1):
                if grid[i][j] == 1:
                    self.bfs(grid, visible, i, j)

        for i, j in product(range(1, m - 1), range(1, n - 1)):
            if grid[i][j] == 1 and visible[i][j] is False:
                grid[i][j] = 0
        return

水流问题

题目描述：

现有一个 N × M 的矩阵，每个单元格包含一个数值，这个数值代表该位置的相对高度。矩阵的左边界和上边界被认为是第一组边界，而矩阵的右边界和下边界被视为第二组边界。

矩阵模拟了一个地形，当雨水落在上面时，水会根据地形的倾斜向低处流动，但只能从较高或等高的地点流向较低或等高并且相邻（上下左右方向）的地点。我们的目标是确定那些单元格，从这些单元格出发的水可以达到第一组边界和第二组边界。

输入描述：

第一行包含两个整数 N 和 M，分别表示矩阵的行数和列数。

后续 N 行，每行包含 M 个整数，表示矩阵中的每个单元格的高度。

输出描述：

输出共有多行，每行输出两个整数，用一个空格隔开，表示可达第一组边界和第二组边界的单元格的坐标，输出顺序任意。

输入示例：

5 5
1 3 1 2 4
1 2 1 3 2
2 4 7 2 1
4 5 6 1 1
1 4 1 2 1

输出示例：

0 4
1 3
2 2
3 0
3 1
3 2
4 0
4 1

提示信息：

在这里插入图片描述
图中的蓝色方块上的雨水既能流向第一组边界，也能流向第二组边界。所以最终答案为所有蓝色方块的坐标。

解题思路：
从上左边界和右下边界作为始点，水流开始往高处流动，最终取两个方向的交集，说明即可往第一组边界流动，也可以往第二组边界流动

  1. 深度优先遍历
class Solution:
    def dfs(self, grid, nums, i, j):
        if i < 0 or j < 0 or i >= len(grid) or j >= len(grid[0]) or (i, j) in nums:
            return
        nums.add((i, j))
        if i - 1 >= 0 and grid[i][j] <= grid[i - 1][j]:
            self.dfs(grid, nums, i - 1, j)
        if i + 1 < len(grid) and grid[i][j] <= grid[i + 1][j]:
            self.dfs(grid, nums, i + 1, j)
        if j - 1 >= 0 and grid[i][j] <= grid[i][j - 1]:
            self.dfs(grid, nums, i, j - 1)
        if j + 1 < len(grid[0]) and grid[i][j] <= grid[i][j + 1]:
            self.dfs(grid, nums, i, j + 1)
        return

    def WaterFlow(self, grid):
        m, n = len(grid), len(grid[0])

        num1 = set()
        num2 = set()
        for i in range(m):
            self.dfs(grid, num1, i, 0)
            self.dfs(grid, num2, i, n - 1)

        for j in range(n):
            self.dfs(grid, num1, 0, j)
            self.dfs(grid, num2, m - 1, j)
        return list(num1 & num2)
  1. 广度优先遍历
class Solution:
    def bfs(self, grid, nums, i, j):
        queue = deque([[i, j]])
        nums.add((i, j))

        while queue:
            cur_x, cur_y = queue.pop()
            if (
                cur_x - 1 >= 0
                and grid[cur_x - 1][cur_y] >= grid[cur_x][cur_y]
                and (cur_x - 1, cur_y) not in nums
            ):
                queue.append([cur_x - 1, cur_y])
                nums.add((cur_x - 1, cur_y))
            if (
                cur_x + 1 < len(grid)
                and grid[cur_x + 1][cur_y] >= grid[cur_x][cur_y]
                and (cur_x + 1, cur_y) not in nums
            ):
                queue.append([cur_x + 1, cur_y])
                nums.add((cur_x + 1, cur_y))
            if (
                cur_y - 1 >= 0
                and grid[cur_x][cur_y - 1] >= grid[cur_x][cur_y]
                and (cur_x, cur_y - 1) not in nums
            ):
                queue.append([cur_x, cur_y - 1])
                nums.add((cur_x, cur_y - 1))
            if (
                cur_y + 1 < len(grid[0])
                and grid[cur_x][cur_y + 1] >= grid[cur_x][cur_y]
                and (cur_x, cur_y + 1) not in nums
            ):
                queue.append([cur_x, cur_y + 1])
                nums.add((cur_x, cur_y + 1))
        return

    def WaterFlow(self, grid):
        m, n = len(grid), len(grid[0])

        num1 = set()
        num2 = set()
        for i in range(m):
            self.bfs(grid, num1, i, 0)
            self.bfs(grid, num2, i, n - 1)

        for j in range(n):
            self.bfs(grid, num1, 0, j)
            self.bfs(grid, num2, m - 1, j)
        return list(num1 & num2)

建造最大岛屿

题目描述：

给定一个由 1（陆地）和 0（水）组成的矩阵，你最多可以将矩阵中的一格水变为一块陆地，在执行了此操作之后，矩阵中最大的岛屿面积是多少。

岛屿面积的计算方式为组成岛屿的陆地的总数。岛屿是被水包围，并且通过水平方向或垂直方向上相邻的陆地连接而成的。你可以假设矩阵外均被水包围。

输入描述：

第一行包含两个整数 N, M，表示矩阵的行数和列数。之后 N 行，每行包含 M 个数字，数字为 1 或者 0，表示岛屿的单元格。

输出描述：

输出一个整数，表示最大的岛屿面积。如果矩阵中不存在岛屿，则输出 0。

输入示例：

4 5
1 1 0 0 0
1 1 0 0 0
0 0 1 0 0
0 0 0 1 1

输出示例

6

提示信息
在这里插入图片描述
对于上面的案例，有两个位置可将 0 变成 1，使得岛屿的面积最大，即 6。

在这里插入图片描述
解决方案：

  1. 分区遍历，将一块岛屿按照新的序号保留下来，同时计算出对应的面积
  2. 遍历grid==0的区域，进行连通，确定最大值
  1. 深度优先遍历：
class Solution:
    def dfs(self, grid, index, i, j):
        if (
            i < 0
            or j < 0
            or i >= len(grid)
            or j >= len(grid[0])
            or grid[i][j] in [0, index]
        ):
            return
        self.cnt += 1
        grid[i][j] = index
        self.dfs(grid, index, i - 1, j)
        self.dfs(grid, index, i + 1, j)
        self.dfs(grid, index, i, j - 1)
        self.dfs(grid, index, i, j + 1)
        return

    def BuildLand(self, grid):
        record = {0: 0}
        m, n = len(grid), len(grid[0])
        index = 2
        maxN = 0
        for i, j in product(range(m), range(n)):
            if grid[i][j] == 1:
                self.cnt = 0
                self.dfs(grid, index, i, j)
                record[index] = self.cnt
                index += 1
                maxN = max(maxN, self.cnt)

        for i, j in product(range(m), range(n)):
            if grid[i][j] == 0:
                sumN = 1
                if i - 1 >= 0:
                    sumN += record[grid[i - 1][j]]
                if i + 1 < m:
                    sumN += record[grid[i + 1][j]]
                if j - 1 >= 0:
                    sumN += record[grid[i][j - 1]]
                if j + 1 < n:
                    sumN += record[grid[i][j + 1]]

                maxN = max(maxN, sumN)
        return maxN
  1. 广度优先遍历
class Solution:
    def bfs(self, grid, index, i, j):
        queue = deque([[i, j]])
        grid[i][j] = index
        cnt = 1
        while queue:
            cur_x, cur_y = queue.pop()

            if cur_x - 1 >= 0 and grid[cur_x - 1][cur_y] == 1:
                queue.append([cur_x - 1, cur_y])
                grid[cur_x - 1][cur_y] = index
                cnt += 1
            if cur_x + 1 < len(grid) and grid[cur_x + 1][cur_y] == 1:
                queue.append([cur_x + 1, cur_y])
                grid[cur_x + 1][cur_y] = index
                cnt += 1
            if cur_y - 1 >= 0 and grid[cur_x][cur_y - 1] == 1:
                queue.append([cur_x, cur_y - 1])
                grid[cur_x][cur_y - 1] = index
                cnt += 1
            if cur_y + 1 < len(grid[0]) and grid[cur_x][cur_y + 1] == 1:
                queue.append([cur_x, cur_y + 1])
                grid[cur_x][cur_y + 1] = index
                cnt += 1
        return cnt

    def BuildLand(self, grid):
        record = {0: 0}
        m, n = len(grid), len(grid[0])
        index = 2
        maxN = 0
        for i, j in product(range(m), range(n)):
            if grid[i][j] == 1:
                cnt = self.bfs(grid, index, i, j)
                record[index] = cnt
                index += 1
                maxN = max(maxN, cnt)

        for i, j in product(range(m), range(n)):
            if grid[i][j] == 0:
                sumN = 1
                if i - 1 >= 0:
                    sumN += record[grid[i - 1][j]]
                if i + 1 < m:
                    sumN += record[grid[i + 1][j]]
                if j - 1 >= 0:
                    sumN += record[grid[i][j - 1]]
                if j + 1 < n:
                    sumN += record[grid[i][j + 1]]

                maxN = max(maxN, sumN)
        return maxN

岛屿的周长

题目描述

给定一个由 1（陆地）和 0（水）组成的矩阵，岛屿是被水包围，并且通过水平方向或垂直方向上相邻的陆地连接而成的。

你可以假设矩阵外均被水包围。在矩阵中恰好拥有一个岛屿，假设组成岛屿的陆地边长都为 1，请计算岛屿的周长。岛屿内部没有水域。

输入描述

第一行包含两个整数 N, M，表示矩阵的行数和列数。之后 N 行，每行包含 M 个数字，数字为 1 或者 0，表示岛屿的单元格。

输出描述

输出一个整数，表示岛屿的周长。

输入示例

5 5
0 0 0 0 0
0 1 0 1 0
0 1 1 1 0
0 1 1 1 0
0 0 0 0 0

输出示例

14

提示信息

在这里插入图片描述
岛屿的周长为 14。

解决方案：
从左上往右下遍历，如果当前位置为1，那周长会增加4，如果当前位置左/下位置也为1，那将会减少2条边，所以只需要计数即可

from itertools import product


class Solution:
    def LaneLength(self, grid):
        m, n = len(grid), len(grid[0])
        cnt1 = 0
        cnt2 = 0
        for i, j in product(range(m), range(n)):
            if grid[i][j] == 1:
                cnt1 += 1
                if i + 1 < m and grid[i + 1][j] == 1:
                    cnt2 += 1
                if j + 1 < n and grid[i][j + 1] == 1:
                    cnt2 += 1
        return 4 * cnt1 - 2 * cnt2

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1837531.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

无引擎底层游戏开发（1）：EasyX图形库引入 + 跟随鼠标移动的小球

无引擎底层游戏开发（1）：EasyX图形库引入 + 跟随鼠标移动的小球

来自bilibili up主的Voidmatrix的视频教程&#xff1a;【从零开始的C游戏开发】 一、图形库引入 EasyX在国内文档最多&#xff0c;而且功能函数齐全&#xff0c;最适合入门。 环境配置&#xff1a;vs2022 &#xff08;官网下载免费版&#xff09; 百度搜EasyX官方&#xff0…
阅读更多...
AI搜索工具,提升你的工作效率

AI搜索工具,提升你的工作效率

当我们需要查询某个内容的时候&#xff0c;除了可以通过搜索引擎来查找&#xff0c;还可以通过AI搜索工具来查找。AI搜索工具会智能的从网络信息中查找答案并整理后给我们结果。除了搜索结果&#xff0c;AI搜索工具还可以用来帮我们创作内容&#xff0c;比如你需要写一篇文章&a…
阅读更多...
【博弈】843. 猜猜这个单词

【博弈】843. 猜猜这个单词

本题涉及知识点 博弈 LeetCode843. 猜猜这个单词 给你一个由 不同 字符串组成的单词列表 words &#xff0c;其中 words[i] 长度均为 6 。words 中的一个单词将被选作秘密单词 secret 。 另给你一个辅助对象 Master &#xff0c;你可以调用 Master.guess(word) 来猜单词&…
阅读更多...
Harbor本地仓库搭建003_Harbor常见错误解决_以及各功能使用介绍_镜像推送和拉取---分布式云原生部署架构搭建003

Harbor本地仓库搭建003_Harbor常见错误解决_以及各功能使用介绍_镜像推送和拉取---分布式云原生部署架构搭建003

首先我们去登录一下harbor,但是可以看到,用户名密码没有错,但是登录不上去 是因为,我们用了负债均衡,nginx会把,负载均衡进行,随机分配,访问的 是harbora,还是harborb机器. loadbalancer中 解决方案,去loadbalance那个机器中,然后 这里就是25机器,我们登录25机器 然后去配置…
阅读更多...
CentOS 7x 使用Docker 安装oracle11g完整方法

CentOS 7x 使用Docker 安装oracle11g完整方法

1.安装docker-ce 安装依赖的软件包 yum install -y yum-utils device-mapper-persistent-data lvm2添加Docker的阿里云yum源 yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo更新软件包索引 yum makecache fast查看docker…
阅读更多...
MacOS - command not found: brew

MacOS - command not found: brew

问题描述 command not found: brew 原因分析 没有安装 Homebrew&#xff0c;安装后即可使用~ 解决方案 打开终端&#xff0c;输入&#xff1a;/bin/zsh -c "$(curl -fsSL https://gitee.com/cunkai/HomebrewCN/raw/master/Homebrew.sh)"&#xff0c;点击回车 在弹出…
阅读更多...
FlinkCDC介绍及使用

FlinkCDC介绍及使用

CDC简介 什么是CDC&#xff1f; cdc是Change Data Capture(变更数据获取)的简称。核心思想是&#xff0c;监测并捕获数据库的 变动(包括数据或数据表的插入&#xff0c;更新以及删除等)&#xff0c;将这些变更按发生的顺序完整记录下来&#xff0c;写入到消息中间件以供其它服…
阅读更多...
归并排序 （递归实+非递归）

归并排序 （递归实+非递归）

前言 归并排序是一种逻辑很简单&#xff0c;但是实现有点难度的排序&#xff0c;尤其是非递归&#xff0c;对于区间的把握更是需要一点逻辑的推导&#xff0c;但是没有关系&#xff0c;轻松拿捏 归并排序gif 归并排序单趟实现 1&#xff0c;创建tmp数组&#xff0c; 2&#xff…
阅读更多...
《Windows API每日一练》4.6 矩形、区域和裁剪

《Windows API每日一练》4.6 矩形、区域和裁剪

在前面的4.3节中我们讲述了绘制矩形的API函数Rectangle和RoundRect。本节我们将介绍另外一组使用RECT矩形结构和区域的绘图函数。 本节必须掌握的知识点&#xff1a; 矩形 第28练&#xff1a;绘制随机矩形 矩形与区域的裁剪 第29练&#xff1a;区域裁剪 4.6.1 矩形 ■FillRe…
阅读更多...
HarmonyOS开发知识 ：扩展修饰器，实现节流、防抖、权限申请

HarmonyOS开发知识 ：扩展修饰器，实现节流、防抖、权限申请

引言 防重复点击&#xff0c;利用装饰器面向切面&#xff08;AOP&#xff09;的特性结合闭包&#xff0c;实现节流、防抖和封装权限申请。 节流 节流是忽略操作&#xff0c;在触发事件时&#xff0c;立即执行目标操作&#xff0c;如果在指定的时间区间内再次触发了事件&…
阅读更多...
C语言中的内存动态管理

C语言中的内存动态管理

1.为什么有动态内存管理 int a20;//开辟4个字节 int arr[10]{0};//开辟40个字节 上述的代码有两个特点 1.开辟空间的大小是固定的。 2.数组在申明的时候已经固定了大小&#xff0c;无法更改。 这样写代码不够灵活&#xff0c;所以c语言中引入了动态内存管理&#xff0c;让程序…
阅读更多...
Java | Leetcode Java题解之第165题比较版本号

Java | Leetcode Java题解之第165题比较版本号

题目&#xff1a; 题解&#xff1a; class Solution {public int compareVersion(String version1, String version2) {int n version1.length(), m version2.length();int i 0, j 0;while (i < n || j < m) {int x 0;for (; i < n && version1.charAt(…
阅读更多...
Flat Ads：全球领先的移动广告营销平台

Flat Ads：全球领先的移动广告营销平台

Flat Ads是全球领先的移动广告营销平台,凭借独家开发者矩阵网络和程序化广告交易平台,帮助广告主在全球范围内精准获取目标用户,提升品牌知名度,实现业务增长目标。同时,Flat Ads也致力于为全球开发者提供高效变现、最大化收益的一站式解决方案,助力开发者实现商业价值最大化。…
阅读更多...
怎么给软件做数字证书签名？

怎么给软件做数字证书签名？

要想让软件获得身份并让计算机识别软件发布者就需要申请数字证书&#xff0c;CA机构严格实名认证后签发的数字证书就可以对指定的软件签名使用。 代码签名是使用数字证书对软件、固件、脚本和可执行文件进行签名的过程&#xff0c;旨在向最终用户和客户保证代码的完整性和真实…
阅读更多...
【论文阅读】-- Attribute-Aware RBFs：使用 RT Core 范围查询交互式可视化时间序列颗粒体积

【论文阅读】-- Attribute-Aware RBFs：使用 RT Core 范围查询交互式可视化时间序列颗粒体积

Attribute-Aware RBFs: Interactive Visualization of Time Series Particle Volumes Using RT Core Range Queries 1 引言2 相关工作2.1 粒子体渲染2.2 RT核心方法 3 渲染彩色时间序列粒子体积3.1 场重构3.1.1 密度场 Φ3.1.2 属性字段 θ3.1.3 优化场重建 3.2 树结构构建与调…
阅读更多...
最新ios苹果手机版植物大战僵尸杂交版下载安装2024六月最新

最新ios苹果手机版植物大战僵尸杂交版下载安装2024六月最新

嘿&#xff0c;亲爱的小可爱们~ &#x1f31f; 今天给你们带来一款超炫的游戏——植物大战僵尸杂交版2024&#xff01;这可不是普通的植物大战僵尸哦&#xff0c;它融合了最新的科技元素和创新玩法&#xff0c;让你在打僵尸的战场上大呼过瘾。快跟着我一起探索这个神奇的游戏世…
阅读更多...
在PHP项目中使用阿里云消息队列MQ集成RabbitMQ的完整指南与问题解决

在PHP项目中使用阿里云消息队列MQ集成RabbitMQ的完整指南与问题解决

在现代Web应用程序中&#xff0c;消息队列系统扮演着至关重要的角色&#xff0c;帮助开发者实现异步处理、削峰填谷、任务调度等功能。阿里云消息队列MQ作为一种高可用、可伸缩的消息队列服务&#xff0c;为开发者提供了可靠的消息投递和处理能力。而RabbitMQ则是一种广泛使用的…
阅读更多...
yolov9-pytorch 深度学习目标检测算法模型

yolov9-pytorch 深度学习目标检测算法模型

YOLOv9 论文 https://arxiv.org/abs/2402.13616 模型结构 YOLOv9将可编程梯度信息 (PGI) 概念与通用 ELAN (GELAN)架构相结合而开发&#xff0c;代表了准确性、速度和效率方面的重大飞跃。 算法原理 Yolov9将可编程梯度信息&#xff08;PGI&#xff09;和GLEAN&#xff08…
阅读更多...
时隔一年，SSD大涨价？

时隔一年，SSD大涨价？

同样产品&#xff0c;2T&#xff0c;去年400多到手&#xff0c;今年700。 去年 今年
阅读更多...
comfyui虚拟试衣、ai换装、电商换装源码

comfyui虚拟试衣、ai换装、电商换装源码

一、AI换装技术博客 1. 项目介绍 IDM-VTON 是一个虚拟试衣模型&#xff0c;可以在 ComfyUI 中进行部署。相比于其他虚拟试衣模型&#xff0c;如 OOTDiffusion&#xff0c;IDM-VTON 提升了图像保真度和细节保留&#xff0c;更强调真实感,而且就算是侧面的模特或者背面的模特都…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023