Python数据结构与算法--数组--扫雷游戏+矩阵变换

扫雷游戏

程序接收三个参数，M，N和p，然后生成一个M * N的矩阵，然后每一个cell有p的概率是地雷。生成矩阵后，再计算出每一个cell周围地雷的数量。

这个程序是一个简单的扫雷游戏实现，主要分为以下几个步骤：

第一步：生成雷区

1. 生成一个(M+2)(N+2 )的矩阵，初始化为 `None`。这样做是为了方便后续计算每个单元格周围的地雷数量。
2. 遍历这个矩阵的M*N子矩阵，使用 `random.random()` 生成一个0到1之间的随机数。
3. 如果这个随机数小于参数 p，则将该单元格标记为地雷（用 `-1` 表示）；否则，标记为非地雷（用 `0` 表示）

第二步：打印雷区

1. 再次遍历M*N子矩阵。
2. 如果某个单元格是地雷（值为 `-1`），则输出 `*`；否则，输出 `.`。

第三步：统计地雷数量

1. 再次遍历M*N子矩阵。
2. 对于每个非地雷单元格（值为 `0`），遍历其周围的九宫格。
3. 检查九宫格中有多少个地雷，并更新该单元格的值。

第四步：输出最终结果

1. 最后一次遍历 \( M \times N \) 子矩阵。
2. 如果某个单元格是地雷（值为 `-1`），则输出 `*`；否则，输出其周围地雷的数量。

import random
#第一步生成雷区
def minesweeper(m, n, p):
    board = [[None] * (n+2) for i in range(m+2)]#扫雷程序中不同位置考虑的九宫格不一样所以扩大整个棋盘空间，加一圈0，保证每一个内部的格子都一样
    for i in range(1, m + 1):#遍历棋盘
        for j in range(1, n + 1):
            r = random.random()#生成一个0-1之间的随机数
            board[i][j] = -1 if r < p else 0
#第二步，把第一步标记好的数字换成雷/点，并打印出来
    for i in range(1, m + 1):#输出含雷棋盘
        for j in range(1, n + 1):
            print("*", end=" ") if board[i][j] == -1 else print(".", end=" ")
        print()
#第三步，统计每一个九宫格中心点周围雷的数量，不打印
    for i in range(1, m + 1):#检查每个非雷位置雷的数量
        for j in range(1, n + 1):#按行来查
            if (board[i][j] != -1):#非雷区
                for ii in range(i-1, i+2):#检查自身九宫格
                    for jj in range(j-1, j+2):
                        if (board[ii][jj] == -1):#查到雷
                            board[i][j] += 1
#第四步，输出棋盘，如果是雷，则输出*，如果不是雷，就输出九宫格的数字  
    print()#空一行
    #把数字键盘转换为雷区键盘，-1代表雷区，其他数字代表自身九宫格存在雷的个数
    for i in range(1, m + 1):
        for j in range(1, n + 1):
            print("*", end=" ") if board[i][j] == -1 else print(board[i][j], end=" ")
        print()

矩阵变换

给一个m×n的矩阵，如果有一个元素为0，则把该元素对应的行与列所有元素全部变成0。

第一步：标记需要置零的行和列

1. 创建两个列表 m 和 n，长度分别是矩阵的行数和列数，并初始化为 None。
2. 遍历矩阵的所有元素。如果找到一个元素为 0，就在 m 和 n 中标记该元素所在的行和列。例如，如果 matrix[i][j] 是 0，那么 m[i] 和 n[j] 都被设置为 1。

第二步：更新矩阵

1. 再次遍历矩阵的所有元素。
2. 对于每个元素 matrix[i][j]，检查其所在的行和列是否被标记（即 m[i] 或 n[j] 是否为 1）。
3. 如果是，则将 matrix[i][j] 设置为 0。

这个算法的时间复杂度是 O(m×n)，因为我们需要遍历整个矩阵两次。空间复杂度是 O(m+n)，用于存储行和列的标记信息。这是一个相当高效的方法，特别是当矩阵的尺寸很大时。

# O(m+n) space complexity
def zero(matrix):
    m = [None] * len(matrix)
    n = [None] * len(matrix[0])
    for i in range(len(matrix)):#按照每行来遍历
        for j in range(len(matrix[0])):#按照每列来遍历
            if (matrix[i][j] == 0):#存在某一个位置为0，就记录下对应的行和列
                m[i] = 1
                n[j] = 1
                
    for i in range(len(matrix)):
        for j in range(len(matrix[0])):
            if (m[i] == 1 or n[j] == 1):
                matrix[i][j] = 0