多维数组和矩阵----边界为1的最大子方阵

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

 {0, 1, 1, 1, 1},
 {0, 1, 0, 0, 1},
 {0, 1, 0, 0, 1},
 {0, 1, 1, 1, 1},
 {0, 1, 0, 1, 1}　
 其中，边框全是1的最大正方形的大小是4*4，返回4

思路：直接枚举，根据阶数递减扫描，每一阶都要遍历所有数组，根据每一个点扫描这个点向右向下向左向上途经的每一个数据能不能构成一个边框全是1的正方形。

代码：

public class MaxSquare {

    public static void main(String[] args) {
//        int[][] A = { 
//                { 0, 1, 1, 1, 1 },
//                { 0, 1, 0, 1, 0 }, 
//                { 0, 1, 1, 1, 1 }, 
//                { 0, 1, 1, 1, 1 }, 
//                { 0, 1, 0, 1, 1 } 
//            };
        int [][]A = new int[][] { 
            { 1, 1, 0, 1 },
            { 1, 1, 1, 1 }, 
            { 1, 1, 0, 1 }, 
            { 1, 1, 1, 1 }, 
        };
        System.out.println("最大子方阵的边长为："+solve(A));
    }
    
    // O(n^4)
    // 直接枚举，根据阶数扫描，每一阶都要遍历所有数组,时间复杂度太高
    static int solve(int [][]A){
        int N = A.length;
        int n = N;
        while(n>0){
            for (int i = 0; i < N; i++) {
                if (i+n>N) break;
                l3:  // 这个语言相当于给第二层for循环命令  下面代码中的continue继续的是第二层的for循环，不是while循环
                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(r<i+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;
                    }
                    r++;
                    return n;
                }
            }
            n--;
        }
        return 0;
    }

}

结果：

　　

优化：这个算法的时间复杂度为N*N*N*(4*N)，为O(N⁴)，时间复杂度太高了，效率不行，我们可以通过对4*N的时间复杂度的优化，将整个解法的时间复杂度降到O(N³)。

思路：我们可以通过对原有矩阵进行预处理的方式，这个思路类似于动态规划中的打表法。我们可以构建一个三维数组，二维平面空间和矩阵大小相同，第三维存储两个元素，第一个元素存储包括自己以及自己右方连续的1的个数，如果自己为0，那么自己就存储为0。第二个元素存储包括自己以及自己下方连续的1的个数，如果自己为0，那么自己也存储为0。通过生成这个辅助表，就可以在判断是否是最大方阵的时候加快判断速度，可以将4个while循环去除，而通过这个辅助表只需判断一次即可，时间复杂度为O(1)，那么整个算法的时间复杂度就为N*N*N了，为O(N³)。

假如矩阵为：
-----------------------------
{ 1, 1, 0, 1 }
{ 1, 1, 1, 1 }
{ 1, 1, 0, 1 }
{ 1, 1, 1, 1 }
-----------------------------
生成的辅助数组为：
-----------------------------
2,4    1,4    0,0    1,4    
4,3    3,3    2,1    1,3    
2,2    1,2    0,0    1,2    
4,1    3,1    2,1    1,1    
-----------------------------

代码：

public class MaxSquare_1 {
    public static void main(String[] args) {
//        int[][] A = { 
//                { 0, 1, 1, 1, 1 },
//                { 0, 1, 0, 1, 0 }, 
//                { 0, 1, 1, 1, 1 }, 
//                { 0, 1, 1, 1, 1 }, 
//                { 0, 1, 0, 1, 1 } 
//            };
        int [][]A = new int[][] { 
            { 1, 1, 0, 1 },
            { 1, 1, 1, 1 }, 
            { 1, 1, 0, 1 }, 
            { 1, 1, 1, 1 }, 
        };
        generateHelpRec(A);
        System.out.println("生成的辅助数组为：");
        System.out.println("=============================");
        print(rec, A.length);
        System.out.println("=============================");
        System.out.println("最大子方阵的边长为："+solve(A));
    }
    
    private static void print(int[][][] rec, int N) {
        for (int i = 0; i < N; i++) {
          for (int j = 0; j < N; j++) {
            System.out.print(rec[i][j][0] + "," + rec[i][j][1] + "	");
          }
          System.out.println();
        }
      }
    
    static int [][][]rec;
    /**
     * 记录每个元素往右和往下有多少个连续的1
     * @param A
     */
    private static void generateHelpRec(int[][] A) {
        int N = A.length;
        rec = new int[N][N][2];
        int row = N-1;
        // 初始化最后一行，因为记录的是往右和往下的，所以必须从最后一行向上初始化,而且从右向左初始化
        for(int j=N-1;j>=0;j--){
            int value = A[row][j];
            if (value==1) {
                if (j==N-1) { // 避免数组越界
                    rec[row][j][0] = 1; // 右边界
                }else {
                    // A的元素值为1，rec在这个位置的连续1的个数 = 右边位置的连续的1的个数+1
                    rec[row][j][0] = rec[row][j+1][0] + 1;
                }
                // 最后一行的下方的1的连续数==1
                rec[row][j][1] = 1;
            }
        }
        row--; //开始初始化倒数第二行到第一行
        for(int i = row;i>=0;i--){
            for (int j = N-1; j>=0; j--) {
                int value = A[i][j];
                // 利用右边和下边已经生产的数据来推出现在这个位置上右侧和下方有多少个1
                if(value==1){
                    if (j==N-1) {
                        rec[i][j][0] = 1;// 右侧连续1的个数
                    }else {
                        rec[i][j][0] = rec[i][j+1][0]+1;
                    }
                    
                    rec[i][j][1] = rec[i+1][j][1] + 1; // 向下连续1的个数
                }
            }
        }
    }

    // O(n³)
    static int solve(int [][]A){
        int N = A.length;
        int n = N;
        while(n>0){
            for (int i = 0; i < N; i++) {
                if (i+n>N) break;
                l3:  // 这个语言相当于给第二层for循环命令  下面代码中的continue继续的是第二层的for循环，不是while循环
                for (int j = 0; j < N; j++) {
                    if (j+n>N) break;
                    if (check(i, j, n))
                        return n;
                }
            }
            n--;
        }
        return 0;
    }

    // O(1)
    private static boolean check(int i, int j, int n) {
        // 左上角那个点往右数的1的数目要大于等于n
        // 左上角那个点往下数的1的数目要大于等于n
        // 右上角那个点往下数的1的个数要大于等于n
        // 左下角那个点往右数的1的个数要大于等于n
        if (rec[i][j][0]>=n&&rec[i][j][1]>=n&&rec[i][j+n-1][1]>=n&&rec[i+n-1][j][0]>=n) {
            return true;
        }
        return false;
    }
    
    
}

结果：

　　

总结：我们再来计算优化过后的时间复杂度为:生成辅助数组所花时间N²+后面循环遍历时间N³，加起来整个算法的时间复杂度就为O(N³)了，那这个算法的效率就比优化前的算法的效率好太多了。