【Educoder作业】问题求解——嵌套列表_python

【Educoder作业】问题求解——嵌套列表

这个实训作业主要针对的是嵌套列表的一种特殊情况——矩阵。就是每层列表长度相等。相当于 C + + C++ C++里的二维数组，每层长度相等。
具体实现的话，以第一题为例：

T1 打印零矩阵

我们定义一个中间列表 m d l ( m i d d l e ) mdl(middle) mdl(middle)，每次把建立好的中间列表扔给我们的 L L L即可。

m = int(input()) #行数
n = int(input()) #列数
########## Begin ##########
L = []
for i in range(m) :
    mdl = [0] * n
    L.append(mdl)
for mdl in L :
    for a in mdl :
        print(a, end = '\t')
    print()
########## End ##########

T2 计算负矩阵

这个题教我们如何进行矩阵遍历。
有一个技巧，这个题目的描述是让我们用第一题的方式建立一个零矩阵，但是我们完全可以直接令 B = A B=A B=A，就得到了一个大小和 A A A相同的矩阵了。不影响之后的赋值 *** 作。

import myMatrix             #myMatrix是自己定义的一个库
num = int(input())
A = myMatrix.getMatrix(num) #利用myMatrix库生成矩阵A
print('A=')
myMatrix.printMatrix(A)     #利用myMatrix库打印矩阵A
########## Begin ##########
B = A
n, m = len(A), len(A[0])
for i in range(n) :
    for j in range(m) :
        B[i][j] = -A[i][j]
########## End ##########
print('\nB=-A=')
myMatrix.printMatrix(B)     #利用myMatrix库打印矩阵B

T3 矩阵相加

虽然 P y t h o n Python Python里的数组支持四则运算但是列表不能。直接相加会让内层直接罗列到一起，不是我们要的。这样的话只好同时遍历两个矩阵，对应元素求和即可。

import myMatrix
num1 = int(input())
num2 = int(input())

A = myMatrix.getMatrix(num1)
print('A=')
myMatrix.printMatrix(A)

B = myMatrix.getMatrix(num2)
print('\nB=')
myMatrix.printMatrix(B)
########## Begin ##########
n, m = len(A), len(A[0])
C = []
for i in range(n) :
    mdl = [0] * m
    C.append(mdl)
for i in range(n) :
    for j in range(m) :
        C[i][j] = A[i][j] + B[i][j]
########## End ##########
print('\nC=A+B=')
myMatrix.printMatrix(C) #打印矩阵C

T4 判断单位矩阵

对应元素判断即可，关键是用好我们之前讲的 f l a g flag flag技巧，戳这里

import myMatrix
num = int(input())
A = myMatrix.getMatrix(num)
print('A=')
myMatrix.printMatrix(A)
########## Begin ##########
flag = True
n, m = len(A), len(A[0])
if n != m :
    flag = False
for i in range(n) :
    for j in range(m) :
        if i != j and A[i][j] :
            flag = False
        if i == j and A[i][j] != 1 :
            flag = False
########## End ##########
if flag == True:
    print('A是单位矩阵')
else:
    print('A不是单位矩阵')

T5 杨辉三角

有点递推的影子了，我们用前两个位置的值得到这个位置。简单说就是两个循环，究其本质我们可以聊两句：
首先，我们需要先知道 a i − 1 , j − 1 , a i − 1 , j a_{i - 1, j - 1},a_{i - 1, j} ai−1,j−1,ai−1,j。如果换成别的题，要注意做递推和 d p dp dp的时候，之前的元素要是有效值。保证我们是按照递推顺序进行的递推。
其次，我们要保证边界问题。如果你的习惯够好，你的数组是从 1 1 1开始的，我们不必考虑这个问题：如果 i = 0 i=0 i=0那么 a i − 1 a_{i - 1} ai−1并不存在。如果强行调用会报错。这就要我们提前设置好 i = 0 i=0 i=0时的值才行，之后的递推就可以直接调用了。

import myMatrix
n = int(input()) #杨辉三角总层数
########## Begin ##########
A = []
for i in range(n) :
    mdl = [0] * n
    A.append(mdl)
for i in range(n) :
    A[i][0] = 1
for i in range(1, n) :
    for j in range(1, n) :
        A[i][j] = A[i - 1][j - 1] + A[i - 1][j]
########## End ##########
myMatrix.printMatrix(A)          #打印矩阵A
print('-'*n*6)                   #打印分隔线
myMatrix.printMatrixAsYangHui(A) #打印杨辉三角

T6 无人机地形导航数据处理

这个题我写了两个版本。
当然，这个题目是容易的，就是遍历除了边界的中间矩阵判断一下即可：

import myMatrix
num = int(input())
A = myMatrix.getMatrix(num)
print('A=')
myMatrix.printMatrix(A)
print('\n山峰坐标：')
########## Begin ##########
n, m = len(A), len(A[0])
for i in range(1, n - 1) :
    for j in range(1, m - 1) :
        if A[i][j] > A[i - 1][j] and A[i][j] > A[i][j - 1] and A[i][j] > A[i + 1][j] and A[i][j] > A[i][j + 1] :
            print(i, j)
########## End ##########

这里介绍一个比较实用的技巧，就是建立方向矩阵：

B = [[0, 1], [0, -1], [1, 0], [-1, 0]]

这里的每一个数对相当于一个方向，每次我们遍历 B B B矩阵就相当于遍历四个方向。这个题确实没啥必要，因为实现起来还需要用 f l a g flag flag进行特判，但是如果有的题是周围八个方向，或者像象棋中的马一样，这种思想就显得必要了。

import myMatrix
num = int(input())
A = myMatrix.getMatrix(num)
print('A=')
myMatrix.printMatrix(A)
print('\n山峰坐标：')
########## Begin ##########
B = [[0, 1], [0, -1], [1, 0], [-1, 0]]
n, m = len(A), len(A[0])
for i in range(1, n - 1) :
    for j in range(1, m - 1) :
        flag = True
        for k in range(len(B)) :
            if A[i][j] <= A[i + B[k][0]][j + B[k][1]] :
                flag = False
        if flag :
            print(i, j)
########## End ##########

T7 飞行炮d空气阻力分析

这个题是容易的，有点麻烦因为我们需要自己写那个 S S S和 v v v。
具体建立矩阵的思想和 T 1 T1 T1是一样的。

import myMatrix
########## Begin ##########
S = [0.005, 0.01, 0.015, 0.02]
v = [100, 200, 300, 400, 500]
C, r = 0.1, 1.2
F = []
for i in range(len(S)) :
    mdl = []
    for j in range(len(v)) :
        mdl.append(round(0.5 * C * r * S[i] * v[j] ** 2))
    F.append(mdl)
########## End ##########
myMatrix.printMatrix(F)    #打印结果
myMatrix.drawMatrixIn3D(F) #绘制图形

T8 幻方

这个题就有那么一点儿 C S P CSP CSP的味道了
这个题也是一个用 f l a g flag flag判断合不合法的题，我们只需要考虑所有的，不合法的情况即可。
首先是，行的和、列的和、对角线的和是否相等。
关于这一点，我们首先建立一个标准值 s t d std std，可以是第一列的值。需要满足之后的所有值都等于 s t d std std。而我们只需要遍历一次矩阵就行，具体看代码。
m d l 1 mdl1 mdl1表示行的和、 m d l 2 mdl2 mdl2表示列的和， s u m 1 , s u m 2 sum1,sum2 sum1,sum2分别记录两个对角线。
除此之外，我们需要判断一下，这个矩阵里的所有值是不是 1 → n 2 1\rightarrow n^2 1→n2
如何判断呢？我们首先建立一个 B B B列表里面存了从 1 1 1到 n 2 n^2 n2。接下来我们将 A A A中的所有元素存入 C C C，排序之后判断和 B B B是不是对应位置相等即可。

import myMatrix
num = int(input())
A = myMatrix.getMatrix(num)
print('A=')
myMatrix.printMatrix(A)
########## Begin ##########
flag = True
n, m = len(A), len(A[0])
if n != m : 
    flag = False
C = []
std = 0
for i in range(n) :
    std += A[i][0]
sum1, sum2 = 0, 0
for i in range(n) :
    sum1 += A[i][i]
    sum2 += A[i][n - 1 - i]
    mdl1, mdl2 = 0, 0
    for j in range(n) :
        C.append(A[i][j])
        mdl1 += A[i][j]
        mdl2 += A[j][i]
    if mdl1 != std or mdl2 != std :
        flag = False
        
B = []
for i in range(1, n * n + 1) :
    B.append(i)
l = len(B)
C.sort()
for i in range(l) :
    if B[i] != C[i] :
        flag = False
        
if sum1 != std or sum2 != std :
    flag = False
########## End ##########
if flag == True:
    print('A是幻方')
else:
    print('A不是幻方')