73. 矩阵置零

这边提供n+m的做法以及更少的思路，对于n+m的做法，我们只需要开辟标记当前行是否存在0以及当前列是否存在0即可，做法如下

class Solution {
    public void setZeroes(int[][] matrix) {
        int arr[]=new int[matrix.length];
        int brr[]=new int[matrix[0].length];

        for(int i=0;i<matrix.length; i++){
            for(int j=0;j<matrix[i].length;j++){
                if(matrix[i][j]==0){
                    arr[i]=1;
                    brr[j]=1;
                }
            }
        }
        for(int i=0;i<matrix.length; i++){
            for(int j=0;j<matrix[i].length;j++){
                if(arr[i]==1||brr[j]==1){
                    matrix[i][j]=0;
                }
            }
        }
        

    }
}

另外一个思路：题目中提到有更好的做法，猜测是遇到当前是0的点，通过hash记录i和j，然后放入数组即可，这样就可以开辟更少的空间，（但要是全是0的话就会开辟n*m，不是很确定思路是否正确）

54. 螺旋矩阵

也就是围着图一直顺时针的绕行，我们开一个标记当前节点是否走过的数组，就会发现每一次我们会先往左走，然后下，然后右，然后上，模拟即可，但是需要注意一点，就是在判断是不是向左边走的时候，应该先判断可不可以向上面走

class Solution {
    public static List<Integer> spiralOrder(int[][] matrix) {

        int [][]arr=new int[matrix.length+3][matrix[0].length+3];
        int [][]mark=new int[matrix.length+3][matrix[0].length+3];

        int n=matrix.length;
        int m=matrix[0].length;
        for(int i=0;i<=n+1;i++){
            for(int j=0;j<=m+1;j++){
                if(i==0||i==n+1||j==0||j==m+1){
                    mark[i][j]=1;
                }
            }
        }
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                arr[i+1][j+1]=matrix[i][j];
            }
        }
        List<Integer> res=new ArrayList<>();
        int i=1;
        int j=1;
        int l=0;
        while(l<n*m){
            res.add(arr[i][j]);
            mark[i][j]=1;
            if(j<m&&mark[i][j+1]==0){
                if(i>1&&mark[i-1][j]==0){
                    i--;
                }
                else{
                    j++;
                }
            }
            else if(i<n&&mark[i+1][j]==0){
                i++;
            }
            else if(j>1&&mark[i][j-1]==0){
                j--;
            }
            else if(i>1&&mark[i-1][j]==0){
                i--;
            }
            l++;
            

        }
        return res;
    }
}

48. 旋转图像

emm，其实就是结论题，我们有两种做法，一个直接枚举1/4的面积，将其对应的点进行轮换，另一个就是先沿着对角线反转，然后每一行进行反转即可

class Solution {
    public static void rotate(int[][] matrix) {
        for(int i=0;i<matrix.length ;i++){
            for(int j=0;j<i;j++){
                int tmp=matrix[i][j];
                matrix[i][j]=matrix[j][i];
                matrix[j][i]=tmp;
            }
        }
        for(int i=0;i<matrix.length;i++){
            int m=matrix[i].length;
            for(int j=0;j<matrix[i].length/2;j++){
                int tmp=matrix[i][j];
                matrix[i][j]=matrix[i][m-j-1];
                matrix[i][m-j-1]=tmp;
            }

        }


    }
}

240. 搜索二维矩阵 II

我们不难发现，n*m的时间复杂度是完全ok的，但是为了降低时间复杂度，我们可以根据当前矩阵的性质，枚举列，找到当前列第一个》=的，如果等于直接返回，然后由于每一列每一行都是递增的，一点点向上枚举即可

class Solution {
   public boolean searchMatrix(int[][] matrix, int target) {

        int j=0;
        int n=matrix.length;
        int m=matrix[0].length;
        for(int i=0;i<m;i++){
            while(j<n&&matrix[j][i]<target){
                j++;
            }
            if(j>=n){
                j=n-1;
            }
            while(j>=0&&matrix[j][i]>target){
                j--;
            }
            if(j<=0){
                j=0;
            }
            if(matrix[j][i]==target){
                return true;
            }
        }
        return false;
    }
}