图论之岛屿系列

图论之岛屿系列

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

深度优先遍历

# 可以直接改原始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": # 过滤条件returngrid[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 < 0or j < 0or i >= len(grid)or j >= len(grid[0])or grid[i][j] == "0"or visible[i][j]):returnvisible[i][j] = Trueself.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 >= 0and 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 >= 0and 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":returngrid[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)returndef numIslands(self, grid: List[List[str]]) -> int:m, n = len(grid), len(grid[0])cnt = 0for i, j in product(range(m), range(n)):if grid[i][j] == "1":self.dfs(grid, i, j)cnt += 1return 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"returndef numIslands(self, grid: List[List[str]]) -> int:m, n = len(grid), len(grid[0])cnt = 0for i, j in product(range(m), range(n)):if grid[i][j] == "1":self.bfs(grid, i, j)cnt += 1return 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:returnself.cnt += 1grid[i][j] = 0self.dfs(grid, i - 1, j)self.dfs(grid, i + 1, j)self.dfs(grid, i, j - 1)self.dfs(grid, i, j + 1)returndef maxAreaOfIsland(self, grid: List[List[int]]) -> int:maxN = 0m, n = len(grid), len(grid[0])for i, j in product(range(m), range(n)):if grid[i][j] == 1:self.cnt = 0self.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] = 0cnt = 1while 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] = 0cnt += 1if 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] = 0cnt += 1if 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] = 0cnt += 1if 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] = 0cnt += 1return cntdef maxAreaOfIsland(self, grid: List[List[int]]) -> int:maxN = 0m, 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:returngrid[i][j] = 0self.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 = 0for 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 += 1return sumN
  1. 广度优先遍历
class Solution:def bfs(self, grid, i, j):queue = deque([[i, j]])grid[i][j] = 0while 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] = 0if 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] = 0if 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] = 0if 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] = 0returndef SumAreaIsolatedLand(self, grid):m, n = len(grid), len(grid[0])sumN = 0for 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 += 1return 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 < 0or j < 0or i >= len(grid)or j >= len(grid[0])or grid[i][j] == 0or visible[i][j] is True):returnvisible[i][j] = Trueself.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)returndef 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] = 0return
  1. 广度优先遍历
class Solution:def bfs(self, grid, visible, i, j):queue = deque([[i, j]])visible[i][j] = Truewhile queue:cur_x, cur_y = queue.pop()if (cur_x - 1 >= 0and grid[cur_x - 1][cur_y] == 1and visible[cur_x - 1][cur_y] is False):queue.append([cur_x - 1, cur_y])visible[cur_x - 1][cur_y] = Trueif (cur_x + 1 < len(grid)and grid[cur_x + 1][cur_y] == 1and visible[cur_x + 1][cur_y] is False):queue.append([cur_x + 1, cur_y])visible[cur_x + 1][cur_y] = Trueif (cur_y - 1 >= 0and grid[cur_x][cur_y - 1] == 1and visible[cur_x][cur_y - 1] is False):queue.append([cur_x, cur_y - 1])visible[cur_x][cur_y - 1] = Trueif (cur_y + 1 < len(grid[0])and grid[cur_x][cur_y + 1] == 1and visible[cur_x][cur_y + 1] is False):queue.append([cur_x, cur_y + 1])visible[cur_x][cur_y + 1] = Truereturndef 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] = 0return

水流问题

题目描述：

现有一个 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:returnnums.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)returndef 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 >= 0and 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 >= 0and 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))returndef 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 < 0or j < 0or i >= len(grid)or j >= len(grid[0])or grid[i][j] in [0, index]):returnself.cnt += 1grid[i][j] = indexself.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)returndef BuildLand(self, grid):record = {0: 0}m, n = len(grid), len(grid[0])index = 2maxN = 0for i, j in product(range(m), range(n)):if grid[i][j] == 1:self.cnt = 0self.dfs(grid, index, i, j)record[index] = self.cntindex += 1maxN = max(maxN, self.cnt)for i, j in product(range(m), range(n)):if grid[i][j] == 0:sumN = 1if 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] = indexcnt = 1while 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] = indexcnt += 1if 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] = indexcnt += 1if 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] = indexcnt += 1if 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] = indexcnt += 1return cntdef BuildLand(self, grid):record = {0: 0}m, n = len(grid), len(grid[0])index = 2maxN = 0for i, j in product(range(m), range(n)):if grid[i][j] == 1:cnt = self.bfs(grid, index, i, j)record[index] = cntindex += 1maxN = max(maxN, cnt)for i, j in product(range(m), range(n)):if grid[i][j] == 0:sumN = 1if 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 productclass Solution:def LaneLength(self, grid):m, n = len(grid), len(grid[0])cnt1 = 0cnt2 = 0for i, j in product(range(m), range(n)):if grid[i][j] == 1:cnt1 += 1if i + 1 < m and grid[i + 1][j] == 1:cnt2 += 1if j + 1 < n and grid[i][j + 1] == 1:cnt2 += 1return 4 * cnt1 - 2 * cnt2

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

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

百数私有化本地部署技术解析，附带独家优惠政策

百数私有化本地部署技术解析，附带独家优惠政策

数据驱动的时代&#xff0c;数据安全性对于每个企业来说都至关重要。私有化本地部署作为一种高效的数据管理方式&#xff0c;越来越受到企业的青睐。然而&#xff0c;高昂的部署费用常常让企业望而却步。 作为一家深耕办公领域10年的低代码公司&#xff0c;百数以本地化部署起…
阅读更多...
Hi3861 OpenHarmony嵌入式应用入门--点灯

Hi3861 OpenHarmony嵌入式应用入门--点灯

本篇实现对gpio的控制&#xff0c;通过控制输出进行gpio的点灯操作。 硬件 我们来操作IO2&#xff0c;控制绿色的灯。 软件 GPIO API API名称 说明 hi_u32 hi_gpio_deinit(hi_void); GPIO模块初始化 hi_u32 hi_io_set_pull(hi_io_name id, hi_io_pull val); 设置某个IO…
阅读更多...
群辉USB Copy套件的使用

群辉USB Copy套件的使用

目录 一、套件安装 二、插入USB设备 三、使用 四、故障排除 有了群辉NAS后，很多U盘、移动硬盘的数据需要备份到NAS中，这时就可以考虑使用USB Copy这个套件了。 USB Copy 乃是群晖上可用于和外接存储设备进行文件复制的一个工具，我常常借助它把外置存储设备的文件拷贝至…
阅读更多...
Kafka集成flume

Kafka集成flume

1.flume作为生产者集成Kafka kafka作为flume的sink&#xff0c;扮演消费者角色 1.1 flume配置文件 vim $kafka/jobs/flume-kafka.conf # agent a1.sources r1 a1.sinks k1 a1.channels c1 c2# Describe/configure the source a1.sources.r1.type TAILDIR #记录最后监控文件…
阅读更多...
Vue2基础：.sync修饰符的使用，认识，作用，本质案例演示，实现父子之间的通信。

Vue2基础：.sync修饰符的使用，认识，作用，本质案例演示，实现父子之间的通信。

.sync的作用&#xff1a; 可以实现子组件与父组件数据的双向绑定&#xff0c;简化代码。 与v-model的不同点,prop属性名可以自定义&#xff0c;不要一定要用value. .sync的本质&#xff1a; 就是&#xff1a;属性名和update&#xff1a;属性名合写。 下面我们进行代码演示…
阅读更多...
mellanox HCA IB网卡固件更新

mellanox HCA IB网卡固件更新

注意事项&#xff1a; 1.如果PSID以SGN开头&#xff0c;说明该产品是曙光的OEM产品&#xff0c;可以向HPC高速网络部获取固件。如果PSID以MT开头&#xff0c;说明该产品是Mellanox或nvidia的标准产品&#xff0c;可以通过官网下载固件。 2.通过官网获取固件&#xff0c;一定要…
阅读更多...
pytorch学习笔记7

pytorch学习笔记7

getitem在进行索引取值的时候自动调用,也是一个魔法方法,就像列表索引取值那样,一个意思 import torchvision from torch.utils.data import DataLoaderdata_transformtorchvision.transforms.Compose([torchvision.transforms.ToTensor()] ) test_datatorchvision.datasets.C…
阅读更多...
如何通过数据库与AI实现以图搜图？OceanBase向量功能详解

如何通过数据库与AI实现以图搜图？OceanBase向量功能详解

OceanBase支持向量数据库的基础能力 当前&#xff0c;数据库存储系统与人工智能技术的结合&#xff0c;可以体现在两个主要的应用方向上。 一、近似搜索。它利用大语言模型&#xff08;LLM&#xff0c;简称大模型&#xff09;的嵌入&#xff08;embedding&#xff09;技术&am…
阅读更多...
解决外网404：清除DNS缓存并配置host主机使用知名公共DNS服务

解决外网404：清除DNS缓存并配置host主机使用知名公共DNS服务

在 Windows 上清除/刷新 DNS 缓存 对于所有Windows版本&#xff0c;清除DNS缓存的过程都是相同的。你需要使用管理员权限打开命令提示符并运行ipconfig /flushdns。 浏览器清除DNS缓存 大多数现代的Web浏览器都有一个内置的DNS客户端&#xff0c;以防止每次访问该网站时…
阅读更多...
防止Selenium被检测 Google Chrome 125

防止Selenium被检测 Google Chrome 125

背景 最近在使用selenium自动播放学习课程&#xff0c;相信大家也有一些类似的使用场景。 能自动化的事情&#xff0c;绝不自己干。 为防止被检测是机器人做题&#xff0c;刷视频&#xff0c;需要做一些小调整。 先来看作为服务方维护者&#xff0c;是如何检测是Selenium打…
阅读更多...
深度神经网络修复策略综述

深度神经网络修复策略综述

源自&#xff1a;软件学报 作者&#xff1a;梁震, 刘万伟, 吴陶然, 薛白, 王戟, 杨文婧 注&#xff1a;若出现无法显示完全的情况&#xff0c;可 V 搜索“人工智能技术与咨询”查看完整文章 摘 要 随着智能信息时代的发展, 深度神经网络在人类社会众多领域中的应用, 尤其是…
阅读更多...
鸿蒙开发实战：灵活定制Tabs组件，实现个性化页签布局

鸿蒙开发实战：灵活定制Tabs组件，实现个性化页签布局

闪客 沉默的闪客 2024-06-16 20:01 陕西 大家好&#xff0c;又一个项目已经基本完成 是一个元服务英语单词卡片项目&#xff0c;后面一步一步的进行分析拆解&#xff0c;今天来实现一个Tabs组件自定义界面开发。 鸿蒙ArkUI 开发的时候&#xff0c;Tabs 组件很常用&#xff0c;…
阅读更多...
Vue项目中实现骨架占位效果-demo

Vue项目中实现骨架占位效果-demo

创建组件 Skeleton.vue <template><div class"skeleton"><div class"skeleton-item" v-for"n in count" :key"n"></div></div> </template><script> export default {props: {count: {ty…
阅读更多...
基于Matlab的细胞计数图像处理系统(GUI界面有报告) 【含Matlab源码 MX_003期】

基于Matlab的细胞计数图像处理系统(GUI界面有报告) 【含Matlab源码 MX_003期】

简介&#xff1a; 本文旨在解决生物血细胞数目统计的挑战&#xff0c;提出了基于图像处理的综合方案。通过MATLAB平台&#xff0c;我们设计并实现了一套完整的细胞图像处理与分析流程。在预处理阶段&#xff0c;采用图像增强和阈值分割等方法&#xff0c;有效地提高了细胞图像的…
阅读更多...
大型语言模型在AMD GPU上的推理优化

大型语言模型在AMD GPU上的推理优化

Large language model inference optimizations on AMD GPUs — ROCm Blogs 大型语言模型&#xff08;LLMs&#xff09;已经改变了自然语言处理和理解&#xff0c;促进了在多个领域中的众多人工智能应用。LLMs在包括AI助手、聊天机器人、编程、游戏、学习、搜索和推荐系统在内的…
阅读更多...
这三款使用的视频、图片设计工具，提供工作效率

这三款使用的视频、图片设计工具，提供工作效率

Videograp Videograp是一款专注于视频生成的工具&#xff0c;特别适合需要快速剪辑和编辑视频的用户。Videograp具备以下特点&#xff1a; 影音比例转换&#xff1a;Videograp支持调整视频的分辨率和比例&#xff0c;使其更适合不同的播放环境和设备。 AI快剪&#xff1a;该工…
阅读更多...
Einops 张量操作快速入门

Einops 张量操作快速入门

张量&#xff0c;即多维数组&#xff0c;是现代机器学习框架的支柱。操纵这些张量可能会变得冗长且难以阅读&#xff0c;尤其是在处理高维数据时。Einops 使用简洁的符号简化了这些操作。 Einops &#xff08;Einstein-Inspired Notation for operations&#xff09;&#xff…
阅读更多...
第二篇： 掌握Docker的艺术：深入理解镜像、容器和仓库

第二篇： 掌握Docker的艺术：深入理解镜像、容器和仓库

掌握Docker的艺术&#xff1a;深入理解镜像、容器和仓库 1. 引言 1.1 简要介绍Docker的重要性 在当今快速发展的技术世界中&#xff0c;软件开发和部署的效率和可靠性是衡量成功的关键因素。Docker&#xff0c;作为一个开源的容器化平台&#xff0c;革新了软件的打包、分发和…
阅读更多...
电致变色和电泳——有什么区别？

电致变色和电泳——有什么区别？

虽然电泳显示器和电致变色显示器都是反射显示器的示例&#xff0c;但其基础技术却截然不同。电致变色显示器采用超薄聚合物&#xff0c;可响应施加的电场而改变颜色。电场使电致变色材料发生化学氧化和还原。这种变化需要的能量很少&#xff0c;而且比较稳定&#xff0c;因此刷…
阅读更多...
PostgreSQL性能优化之分区表 #PG培训

PostgreSQL性能优化之分区表 #PG培训

在处理大规模数据时&#xff0c;PostgreSQL的性能优化是一个非常重要的话题&#xff0c;其中分区表&#xff08;Partitioned Tables&#xff09;是提高查询和数据管理效率的重要手段。本文将详细介绍PostgreSQL分区表的概念、优势、创建与管理方法以及一些常见的优化策略。 #P…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023