蓝桥杯算法基础（24）：多维数组与矩阵（4道小题）java版

题1:顺时针打印二维数组

static void print(int[][] matrix){
    int leftUpRow=0,leftUpCol=0,rightDownRow=matrix.length-1,rightDownCol=matrix[0].length-1;

    while(leftUpRow<=rightUpRow&&leftUpCol<=rightDownCol){
    //在不是方阵的情况下，是扁平的时，左右或是上下间距小的先结束，
    //也就是说最后肯定剩一行，无论是竖着一行还是横着一行，上一行结束后，
    //上下左右边界改变，间距小的合并到一起，当遍历到头时，由于有一个间距已经变为0，
    //有些while循环无法实现，只有间距不为0那个方向可以动，因此当结束时，
    //再次更新边界，两个为0的边界就交叉了，循环结束


    //         leftUpCol
    //leftUpRow    0


    //                     length    rightDownRow
    //                   rightDownCOl



    //两个移动指针
    int r=leftUpRow;
    int c=leftUpCol;

    //上面一条边
    while(c<=rightUpCol){
        System.out.println(matrix[leftUpRow][c++]+" ");
    }
    //恢复
    c=rightDownCol;

    r++;
    //右边的一条边
    while(r<=rightDownRow){
    System.out.println(matrix[r++][leftUpCol]+" ");
    }

    //恢复
    r=rightDownRow;
    c--;

    //下面一条边
    while(c>=RightDown){
    System.out.println(matrix[r][c--]+" ");
    }

    //恢复
    c=leftUpCol;
    r--;
    while(r>leftUpRow){
    System.out.println(matrix[r--][c]);
    }

    一圈后回到左顶角
    leftUpRow++;
    leftUpCol++;
    rightUpRow--;
    rightUpCol--;
    }
}

题2:0所在的行列清零

如果矩阵中某个元素为0，则将其所在行和列清零
1  2  3  4
5  6  0  8
9  0  11 12
13 14 15 16


先记录再求解决
static void solve(int[][] matrix){
 int M=matrix.length;
 int N=matrix[0].length;
 //记录那些行出现了0
 int[] rowRecord=new int[M];
 //记录那些列出现了0
 int[] colRecord=new int[N];
 for(int i=0;i<M;i++){
  for(int j=0;j<N;j++){
     if(matrix[i][j]==0){
    rowRecord[i]=1;
    colRecord[j]=1;
    }
  }
 }

 for(int row=0;row<M;row++){
    for(int col=0;col<N;col++){
    if(rowRecord[row]==1||colRecord[col]==1)
        matrix[row][col]=0;
    }
 }

}

题3:z型打印

1  2  3  4
5  6  7  8
9  10 11 12

static void print(int[][] matrix){
 int r=0;m=matrix.length;//行的长度
 int c=0;n=matrix[0].length;//每一列的长度
    boolean l2r=true;//从左到右
    while(r<m&&c<n){//全都遍历完，才终止条件

    //从左下到右上的斜线，若是到边界，则这个条件结束
    if(12r){
    System.out.println(matrix[r][c]+" ");
    //现在在第一行，列未到边界，这是只能向左走

    //在上和右边界，都要调换方向，从上破转到下坡
    if(r==0&&c<n-1){//走上坡的终止条件，当到达最上方且未到最右方，就往右走一步
    l2r=!l2r;//掉换方向，从上坡到下坡
    c++;
    continue;
    }else if(r>0&&c=n-1){
    l2r=!l2r;
    r++;
    continue;
    }else{//急需走上坡
    r--;
    c++;
    }else{//走上坡结束,该走下坡了
    //在左和下边界，都要调换方向，从下坡上坡
    System.out.println(matrix[i][j]+" ");

    if(c==0&&r<m-1){//走下坡的边界，若是碰到
    l2r=!l2r;
    r++;
    continue;
    }else if(r==m-1){
    l2r=!l2r;
    c++;
    continue;
    }else{

    r++;
    c--;
    }

    }


    }

}

题4:边长为1的最大子方阵

给定一个N*N的矩阵matrix，在这个矩阵中，只有0和1两种值，返回边框全是1的最大正方形的边长长度

//外围循环为边长，内层循环为在该边长下，每个点位作为左上顶点，遍历四条边，看是否有0，若有0，则该方阵不成立，若没有0，则此方阵为最大子方阵
private static int solve(int[][] A){
     int N=A.length;
     int n=N;
     while(n>0){
     for(int i=0;i<N;i++){
        l3;
        if(i+n>N)break;//越界
        for(int j=0;j<N;j++){

        if(j+n>N)break;//越界
        //检查四个边
        int r=i,c=j;
        while(c<j+n){
        if(A[r][c++]==0)continue l3;
        }
        c--

        while(c<j+n){
            if(A[r++][c]==0)
            continue l3;
        }
        r--;
        while(c>=j){
        if(A[r][c--]==0)
        continue l3;
        }
        c++;
        while(r>=i){
        if(A[r--][c]==0)
        continue l3;
        }
        //若是都没有退出，则这就最大的边长，因为外围为边长，他是从大到小遍历的

        return n;
        }
     }

     }
}