查找上，下，左或右至少有1个点的点数

这个主题涉及到一个二维矩阵中查找上、下、左或右至少有1个点的点数。这可以用来解决许多问题，如连通性问题等。

实现方式

我们可以使用深度优先搜索 (DFS) 或广度优先搜索 (BFS) 来实现这个问题。

DFS

在 DFS 的实现中，我们可以从矩阵中的每个位置开始，向上、下、左或右四个方向搜索，并标记已经被搜索过的位置。在这个过程中，我们可以记录被标记的位置的数量，这就是我们要找的结果。

def dfs(matrix):
    n = len(matrix)
    m = len(matrix[0])
    visited = [[False for _ in range(m)] for _ in range(n)]
    count = 0

    def helper(i, j):
        if i < 0 or i >= n or j < 0 or j >= m or matrix[i][j] == 0 or visited[i][j]:
            return
        visited[i][j] = True
        nonlocal count
        count += 1
        helper(i-1, j)
        helper(i+1, j)
        helper(i, j-1)
        helper(i, j+1)

    for i in range(n):
        for j in range(m):
            if matrix[i][j] == 1 and not visited[i][j]:
                helper(i, j)

    return count

在这个实现中，我们先初始化了一个 visited 数组来记录每个位置的搜索状态。在 helper 方法中，我们首先判断 (i, j) 位置是否越界，其次判断该位置是否已经被搜索，最后判断这个位置上是否有一个点，如果满足，则将其标记为已搜索，并将计数器加1。随后，我们会递归地搜索上、下、左或右四个方向。

最后，我们遍历矩阵的所有位置，如果该位置还未被搜索，且上面有一个点，则使用 helper 函数进行DFS搜索。最终，我们返回计数器 count。

BFS

与 DFS 类似，我们可以使用 BFS 来实现该问题。在 BFS 实现中，我们使用一个队列来存储要搜索的节点，每当我们找到一个未搜索过的节点时，我们将其加入队列中，并标记为已经搜索。在遍历完队列后，被标记为 True 的数量就是我们要找的结果。

def bfs(matrix):
    n = len(matrix)
    m = len(matrix[0])
    visited = [[False for _ in range(m)] for _ in range(n)]
    count = 0

    queue = []
    for i in range(n):
        for j in range(m):
            if matrix[i][j] == 1 and not visited[i][j]:
                queue.append((i, j))
                visited[i][j] = True
                count += 1
                while queue:
                    x, y = queue.pop(0)
                    if x-1 >= 0 and matrix[x-1][y] == 1 and not visited[x-1][y]: # 上
                        queue.append((x-1, y))
                        visited[x-1][y] = True
                    if x+1 < n and matrix[x+1][y] == 1 and not visited[x+1][y]: # 下
                        queue.append((x+1, y))
                        visited[x+1][y] = True
                    if y-1 >= 0 and matrix[x][y-1] == 1 and not visited[x][y-1]: # 左
                        queue.append((x, y-1))
                        visited[x][y-1] = True
                    if y+1 < m and matrix[x][y+1] == 1 and not visited[x][y+1]: # 右
                        queue.append((x, y+1))
                        visited[x][y+1] = True

    return count

在这个实现中，我们首先初始化了 visited 数组，并记录了点的数目 count。接下来，我们遍历了矩阵中的每个点，并在点为1且未被访问的情况下，将该点入队列，标记为已访问并将 count 加1。在执行 BFS 搜索时，我们会遍历队列中的每个节点，并考虑其四个方向上相邻的节点是否可搜索。如果相邻节点可以搜索，则将其加入队列并标记状态。

最终，我们返回 count 计数器的值。

总结

这里我们提供了两种方法来查找二维矩阵中至少有 1 个点相邻的点的数量。DFS 和 BFS 都可以实现此功能，具体选择哪一个算法取决于输入数据的特点和个人喜好。

无论选择哪种算法，都需要记录遍历状态，并从每个新的节点开始遍历相邻的节点。在记录遍历状态时，我们可以使用一个 visited 数组来进行标记。