每日一题——Python实现PAT乙级1050 螺旋矩阵（举一反三+思想解读+逐步优化）6千字好文

一个认为一切根源都是“自己不够强”的INTJ

个人主页：用哲学编程-CSDN博客
专栏：每日一题——举一反三
Python编程学习
Python内置函数

Python-3.12.0文档解读

我的写法

时间复杂度分析

空间复杂度分析

总结

我要更强

代码解释

时间复杂度

空间复杂度

总结

哲学和编程思想

哲学思想

编程思想

总结

举一反三

1. 模块化设计

2. 抽象化

3. 迭代与递归

4. 算法优化

5. 数据结构选择

6. 边界条件处理

7. 简约主义

8. 秩序与结构

题目链接：https://pintia.cn/problem-sets/994805260223102976/exam/problems/type/7?problemSetProblemId=994805275146436608&page=0

我的写法

import math# 读取矩阵元素的数量
N = int(input())
# 读取数字列表并按降序排序
nums = list(map(int, input().split()))
nums.sort(reverse=True)def find_dimensions(N):# 找到最接近N的平方根的整数middle = math.isqrt(N)# 从middle开始向上找，直到找到两个数乘积为Nfor i in range(middle, N+1):for j in range(middle, 0, -1):if i * j == N:return i, jdef create_spiral_matrix(N, nums, m, n, seq_paces):# 初始化矩阵matrix = [[0 for i in range(n)] for j in range(m)]index_matrix = [0, -1]  # 矩阵索引初始位置index_nums = 0  # 数字列表索引for i in range(len(seq_paces)):if i % 4 == 0:  # 向右移动seq_paces[i]步index_matrix[1] += 1for j in range(seq_paces[i]):matrix[index_matrix[0]][index_matrix[1] + j] = nums[index_nums]if j == seq_paces[i] - 1:index_matrix[1] = index_matrix[1] + jindex_nums += 1elif i % 4 == 1:  # 向下移动seq_paces[i]步index_matrix[0] += 1for j in range(seq_paces[i]):matrix[index_matrix[0] + j][index_matrix[1]] = nums[index_nums]if j == seq_paces[i] - 1:index_matrix[0] = index_matrix[0] + jindex_nums += 1elif i % 4 == 2:  # 向左移动seq_paces[i]步index_matrix[1] -= 1for j in range(seq_paces[i]):matrix[index_matrix[0]][index_matrix[1] - j] = nums[index_nums]if j == seq_paces[i] - 1:index_matrix[1] = index_matrix[1] - jindex_nums += 1elif i % 4 == 3:  # 向上移动seq_paces[i]步index_matrix[0] -= 1for j in range(seq_paces[i]):matrix[index_matrix[0] - j][index_matrix[1]] = nums[index_nums]if j == seq_paces[i] - 1:index_matrix[0] = index_matrix[0] - jindex_nums += 1return matrixdef calculate_sequence_paces(N, m, n):# 计算螺旋填充的步数序列if m == 1:return [n]elif n == 1:return [1, m - 1]seq_paces = []dif = 0for i in range(N):if i == 0:seq_paces.append(n)dif += 1continueif i % 2 == 1:seq_paces.append(m - dif)elif i % 2 == 0:seq_paces.append(n - dif)dif += 1if seq_paces[-1] == 0:return seq_paces[:-1]return seq_paces# 找到矩阵的维度
m, n = find_dimensions(N)
# 计算螺旋填充的步数序列
seq_paces = calculate_sequence_paces(N, m, n)
# 创建螺旋矩阵
matrix = create_spiral_matrix(N, nums, m, n, seq_paces)
# 输出矩阵
for row in matrix:print(*row)

时间复杂度分析

排序：对 N 个数字进行排序的时间复杂度是 O(N log N)。
find_dimensions：这个函数在最坏情况下需要检查大约 sqrt(N) 个可能的行和列组合，因此时间复杂度大约是 O(N)。
calculate_sequence_paces：这个函数在最坏情况下需要遍历 N 次，时间复杂度也是 O(N)。
create_spiral_matrix：这个函数需要遍历所有步数序列，步数序列的长度大约是 sqrt(N)，每次填充矩阵的时间复杂度是 O(N)，所以总时间复杂度也是 O(N)。

综合来看，主要的时间消耗来自于排序和矩阵填充，因此总时间复杂度是 O(N log N)。

空间复杂度分析

排序：排序需要的额外空间复杂度是 O(N)。
矩阵：矩阵的大小是 O(N)。
步数序列：步数序列的大小大约是 sqrt(N)。

综合来看，主要的空间消耗来自于矩阵和排序，因此总空间复杂度是 O(N)。

总结

这段代码在功能上实现了将一组数字按螺旋顺序填充到矩阵中，并且在时间和空间复杂度上都是高效的。代码结构清晰，函数职责明确，易于理解和维护。主要的时间消耗来自于排序和矩阵填充，而空间消耗主要由矩阵和排序决定。总体来说，这是一段设计良好且高效的代码。

我要更强

为了解决这个问题，我们需要完成以下步骤：

读取输入的数字数量 N 和数字列表。
对数字列表进行降序排序。
找到满足 m * n = N 且 m >= n 的矩阵维度 m 和 n，并且使得 m - n 最小。
创建一个空的螺旋矩阵，并按照顺时针方向填充数字。
输出填充好的螺旋矩阵。

以下是实现上述步骤的Python代码：

import math# 读取输入
N = int(input())
nums = list(map(int, input().split()))# 对数字列表进行降序排序
nums.sort(reverse=True)# 找到合适的矩阵维度
def find_dimensions(N):min_diff = float('inf')m, n = 0, 0for i in range(1, int(math.sqrt(N)) + 1):if N % i == 0:j = N // iif j >= i and j - i < min_diff:min_diff = j - im, n = j, ireturn m, nm, n = find_dimensions(N)# 创建并填充螺旋矩阵
matrix = [[0] * n for _ in range(m)]
top, bottom, left, right = 0, m - 1, 0, n - 1
index = 0while top <= bottom and left <= right:# 向右填充for i in range(left, right + 1):matrix[top][i] = nums[index]index += 1top += 1# 向下填充for i in range(top, bottom + 1):matrix[i][right] = nums[index]index += 1right -= 1# 向左填充if top <= bottom:for i in range(right, left - 1, -1):matrix[bottom][i] = nums[index]index += 1bottom -= 1# 向上填充if left <= right:for i in range(bottom, top - 1, -1):matrix[i][left] = nums[index]index += 1left += 1# 输出螺旋矩阵
for row in matrix:print(' '.join(map(str, row)))

代码解释

输入读取：首先读取输入的数字数量 N 和数字列表 nums。
排序：对数字列表 nums 进行降序排序。
找到矩阵维度：定义 find_dimensions 函数来找到合适的矩阵维度 m 和 n，使得 m * n = N 且 m >= n，并且 m - n 最小。
填充矩阵：创建一个空的矩阵 matrix，并使用边界指针（top, bottom, left, right）来控制填充方向，按照顺时针方向填充数字。
输出矩阵：最后，输出填充好的螺旋矩阵。

这个代码在时间和空间复杂度上都是高效的，并且能够正确地解决给定的问题。

代码结构和逻辑

输入处理：代码首先读取输入的数字数量 N 和数字列表 nums，这一部分的时间复杂度是 O(N)，因为需要读取和存储 N 个数字。
排序：对数字列表 nums 进行降序排序，使用的是 Python 内置的 sort 方法，其时间复杂度是 O(N log N)。
找到矩阵维度：定义 find_dimensions 函数来找到合适的矩阵维度 m 和 n。这个函数的时间复杂度是 O(sqrt(N))，因为它只需要遍历到 sqrt(N) 的整数。
填充矩阵：创建一个空的矩阵 matrix，并使用边界指针（top, bottom, left, right）来控制填充方向，按照顺时针方向填充数字。这一部分的时间复杂度是 O(N)，因为每个数字只被处理一次。
输出矩阵：最后，输出填充好的螺旋矩阵。这一部分的时间复杂度也是 O(N)，因为需要遍历并输出每个元素。

时间复杂度

综合以上分析，主要的时间消耗来自于排序和矩阵填充。因此，总的时间复杂度是 O(N log N)。

空间复杂度

输入存储：需要存储 N 个数字，空间复杂度是 O(N)。
排序：排序过程中需要额外的空间，但由于 Python 的 sort 方法是原地排序，所以这部分的空间复杂度可以忽略不计。
矩阵存储：需要存储一个 m * n 的矩阵，空间复杂度是 O(N)。

因此，总的空间复杂度是 O(N)。

总结

这段代码在功能上实现了将一组数字按螺旋顺序填充到矩阵中，并且在时间和空间复杂度上都是高效的。代码结构清晰，函数职责明确，易于理解和维护。主要的时间消耗来自于排序和矩阵填充，而空间消耗主要由矩阵和输入数据决定。总体来说，这是一段设计良好且高效的代码。

哲学和编程思想

这段代码体现了多个哲学和编程思想，以下是一些主要的思想：

哲学思想

秩序与结构：哲学上，秩序和结构是宇宙的基本原则。这段代码通过将无序的数字列表转换为有序的螺旋矩阵，体现了对秩序和结构的追求。
简约主义：代码尽量保持简洁和高效，避免不必要的复杂性。这种简约主义的思想在代码的结构和逻辑中得到了体现。

编程思想

模块化：代码被划分为多个函数，每个函数负责一个特定的任务（如输入处理、排序、找到矩阵维度、填充矩阵和输出矩阵）。这种模块化的设计使得代码更易于理解和维护。
抽象化：通过定义 find_dimensions 函数来抽象出找到矩阵维度的逻辑，使得主逻辑更加简洁。这种抽象化的思想有助于隐藏复杂性，提高代码的可读性。
迭代与递归：虽然代码中没有显式的递归，但通过边界指针的迭代方式来填充矩阵，体现了迭代思想。迭代是一种逐步推进的解决问题的方法，适用于处理有序数据。
算法优化：在找到矩阵维度的过程中，代码通过遍历到 sqrt(N) 的整数来减少计算量，体现了算法优化的思想。这种优化减少了不必要的计算，提高了效率。
数据结构选择：代码选择了列表和二维列表（矩阵）作为主要的数据结构，这种选择是基于问题的需求和数据结构的特性。合理选择数据结构是编程中的重要思想。
边界条件处理：在填充矩阵的过程中，代码通过边界指针来控制填充方向，并处理边界条件。这种对边界条件的细致处理是编程中的重要思想，有助于避免错误和提高代码的健壮性。