leetcode刷题之python矩阵相关题目

一、开始

话不多说，下一个环节！感慨都在刷题后！

二、题目解析

1.统计有序矩阵中的负数（1351）难度：简单

class Solution:
    def countNegatives(self,grid:List[List[int]])->int:
        count=0
        n=len(grid)
        for i in range(0,n):
            for j in range(0,len(grid[i])):
                if grid[i][j]<0:
                    count+=1
        return count

矩阵在python的列表中就相当于列表的嵌套；

首先，定义一个计数器count，返回给定列表的长度；

然后做循环嵌套，依次遍历列表中列表的值，若小于0，则count加1，最后返回count即可。

2.矩阵对角线元素的和（1572）难度：简单

class Solution:
    def diagonalSum(self,mat:List[List[int]])->int:
        sum=0
        n=len(mat)
        for i in range(0,n):
            sum+=mat[i][i]
            mat[i][i]=0
            sum+=mat[i][n-i-1]
        return sum

矩阵对角线元素之后，不要忘了有主对角线与副对角线，但这时候还有一个问题，当矩阵为奇数阶时，按照依次遍历时中间元素会重复，简单的思路我们可以用if做一个对奇数偶数的判断，当然也有更好的方法，每次加完之后就将主对角线上的元素重新赋值为0即可，巧妙而简单！

3.最富有客户的资产总量（1672）难度：简单

class Solution:
    def maximumWealth(self,accounts:List[List[int]])->int:
        sum_1=0
        n=len(accounts)
        max_sum=sum(accounts[0][:])
        for i in range(n):
            for j in range(len(accounts[i])):
                sum_1+=accounts[i][j]
            if sum_1>max_sum:
                max_sum=sum_1
            sum_1=0
        return max_sum

这道题目也就是分别对列表中的列表分别求和最后返回其中最大值即可；

有两种思路，一个是可以用if条件语句做比较直到最后输出最大值；

另一个可以建立一个列表存放每个的和，最后用max返回其中最大的值。

4.托普利茨矩阵（766）难度：简单

class Solution:
    def isToeplitzMatrix(self,matrix:List[List[int]])->int:
        m=len(matrix)        
        n=len(matrix[0])
        for i in range(m-1):
            for j in range(n-1):
                if matrix[i][j]!=matrix[i+1][j+1]:
                    return False
        return True

理解托普利茨矩阵的意义，即判断每个元素的右下角元素是否与其相等即可，如果存在不相等的情况，直接返回False，遍历完之后如果正确返回True。

5.矩阵中的幸运数（1380）难度：简单

class Solution:
    def luckyNumbers(self,matrix:List[List[int]])->List[int]:
        m=len(matrix)
        n=len(matrix[0])
        min_row=[]
        max_col=[]
        
        for i in range(m):
            min_rpw.append(min(matrix[i]))
        for j in range(n):
            max_1=0
            for i in range(m):
                if matrix[i][j]>max_1:
                    max_1=matrix[i][j]
            max_col.append(max_1)

        result=[]
        for i in range(m):
            for j in range(n):
                if matrix[i][j]==min_row[i] and martix[i][j]==max_col[j]:
                    result.append(matrix[i][j])
        return result

寻找矩阵中的幸运数，即一行中最小的数同时又是一列中最大的数，这样的数可能不唯一，所以我们建立一个储存答案的列表；

这道题目也就分为了两个部分；

首先分别返回一个含有每行中最小元素的列表与每列中最大元素的列表；

遍历整个列表，判断数是否是一行中最小的同时又是一列中最大的元素，最后返回result的列表即可。

6.二进制矩阵中的特殊位置（1582）难度：简单

这道题目截图了，因为这道题目不是自己做出来的；代码放上，供大家使用；如果有好的建议也可以一起讨论。

7. 岛屿的周长（463）难度：简单

class Solution:
    def islandPerimeter(self,grid:List[List[int]])->int:
        row=len(grid)
        col=len(grid)
        sum_side=0
        for i in range(row):
            for j in range(col):
                if grid[i][j]==1:
                    sum_side+=4
                    if i-1>=0 and grid[i-1][j]==1:
                        sum_side-=1
                    if i+1<row and grid[i+1][j]==1:
                        sum_side-=1
                    if j-1>=0 and grid[j-1][i]==1:
                        sum_side-=1
                    if j+1<col and grid[j+1][i]==1:
                        sum_side-=1
        return sum_side

这道题目标着简单其实也不是很简单吧，对我这种刷题初学者来说还是能感受到一些压力的，不过也是这种在舒适区边缘的题目可以帮助我们更好的成长；

这道题的思路其实也就是当遇见陆地的时候先加上四条边，然后判断其上下左右的数是否为1，若为1，则减去一条边即可，最后返回sum_side。

今天的题目一半轻松一半有难度吧，能感受到难度，经过一些思考最后还能做出来，这样的进步才是最大的进步；

不积跬步无以至千里，不积小流无以成江海！

提升并非一日之功，刷题也未必总能做出来，难得的是不断去做，一直坚持！！！