leetcode分类刷题：矩阵顺时针模拟

1、这种题目是对代码熟练度考察，模拟顺时针建立或访问矩阵，需要注意矩阵是否为方阵
2、具体思路：以圈数为循环条件，每一圈都坚持左闭右开的区间规则；当小的行列值为奇数，最后一圈为一行或一列或一个数字的不完整圈
3、细节：把 起始圈的上下左右边界 和 i,j标记矩阵的赋值位置 放在圈数循环外部，以方便完整圈数遍历完后使用这些变量；同时，圈数循环内部的最后要对这些变量进行更新

59. 螺旋矩阵 II

from typing import List
'''
59. 螺旋矩阵 II
题目描述：给你一个正整数 n ，生成一个包含 1 到 n^2 的所有元素，且元素按顺时针顺序螺旋排列的 n i n 正方形矩阵 matrii 。
示例 1:
    输入：n = 3
    输出：[[1,2,3],[8,9,4],[7,6,5]]
题眼：代码熟练度考察，模拟顺时针建立矩阵，注意是方阵，复杂度降低了些
思路：以圈数为循环条件，每一圈都坚持左闭右开的区间规则；当n为奇数，恰好留了一个中心元素待更新
注意把 起始圈的上下左右边界 和 i,j标记矩阵的赋值位置 放在圈数循环外部，以方便圈数遍历完后使用这些变量；同时，圈数循环内部的最后要对这些变量进行更新
'''


class Solution:
    def generatedMatrii(self, n: int) -> List[List[int]]:
        result = [[0] * n for _ in range(n)]
        # 以圈数为循环条件，每一圈都坚持左闭右开的区间规则
        count = 1
        up, down, left, right = 0, n - 1, 0, n - 1  # 起始圈的上下左右边界
        i, j = up, left  # i,j标记矩阵的赋值位置，初始值为左上角坐标
        for _ in range(n // 2):  # 总圈数为 n // 2
            while i == up and j < right:  # 上
                result[i][j] = count
                j += 1
                count += 1
            while i < down and j == right:  # 右
                result[i][j] = count
                i += 1
                count += 1
            while i == down and j > left:  # 下
                result[i][j] = count
                j -= 1
                count += 1
            while i > up and j == left:  # 左
                result[i][j] = count
                i -= 1
                count += 1
            # 更新圈的上下左右边界
            up, down, left, right = up + 1, down - 1, left + 1, right - 1
            i, j = up, left  # i,j标记矩阵的赋值位置，初始值为左上角坐标
        # 当n为奇数，恰好留了一个中心元素待更新
        if n % 2 == 1:
            result[up][left] = count
        return result


if __name__ == "__main__":
    obj = Solution()
    while True:
        try:
            n = int(input().strip().split('=')[1])
            print(obj.generatedMatrii(n))
        except EOFError:
            break

54. 螺旋矩阵

from typing import List
'''
54. 螺旋矩阵
题目描述：给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。
示例 1:
    输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
    输出：[1,2,3,6,9,8,7,4,5]
题眼：代码熟练度考察，模拟顺时针返回矩阵元素，注意不是方阵，有点复杂度
思路：以圈数为循环条件，每一圈都坚持左闭右开的区间规则；当小的行列值为奇数，最后一圈为一行或一列或一个数字的不完整圈
注意把 起始圈的上下左右边界 和 i,j标记矩阵的赋值位置 放在圈数循环外部，以方便圈数遍历完后使用这些变量；同时，圈数循环内部的最后要对这些变量进行更新
'''


class Solution:
    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
        m, n = len(matrix), len(matrix[0])
        result = []
        # 以圈数为循环条件，每一圈都坚持左闭右开的区间规则
        up, down, left, right = 0, m - 1, 0, n - 1  # 起始圈的上下左右边界
        i, j = up, left  # i,j标记矩阵的赋值位置，初始值为左上角坐标
        for _ in range(min(m, n) // 2):  # 总圈数为 小的行列值除以2
            while i == up and j < right:  # 上
                result.append(matrix[i][j])
                j += 1
            while i < down and j == right:  # 右
                result.append(matrix[i][j])
                i += 1
            while i == down and j > left:  # 下
                result.append(matrix[i][j])
                j -= 1
            while i > up and j == left:  # 左
                result.append(matrix[i][j])
                i -= 1
            # 更新圈的上下左右边界
            up, down, left, right = up + 1, down - 1, left + 1, right - 1  # 起始圈的上下左右边界
            i, j = up, left  # i,j标记矩阵的赋值位置，初始值为左上角坐标
        # 当小的行列值为奇数，最后一圈为一行或一列或一个数字的不完整圈
        if min(m, n) % 2 == 1:
            if up == down and left == right:  # 一个数字
                result.append(matrix[up][left])
            elif up != down and left == right:  # 一列，对应的列索引为left
                for k in range(up, down + 1):
                    result.append(matrix[k][left])
            elif up == down and left != right:  # 一行，对应的行索引为up
                for k in range(left, right + 1):
                    result.append(matrix[up][k])
        return result


if __name__ == "__main__":
    obj = Solution()
    while True:
        try:
            in_line = input().strip().split('=')
            matrix = []
            for row in in_line[1].strip()[1: -1].split(']')[: -1]:
                matrix.append([int(n) for n in row.split('[')[1].split(',')])
            print(obj.spiralOrder(matrix))
        except EOFError:
            break