最大正方形的边长长度问题解法

问题描述：

        给定一个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。

思路

        首先我们知道在N*N的举证中存在如下两个结论：

        1.边长为N的矩阵中长方形的个数数量级是O(N^4)。

        这是因为：在N*N的矩阵中随机抽取一个点的数量级为O(N^2)，在N*N的矩阵中抽取两个点分别作为长方形的对角点，即长方形的数量级为O(N^2) * O(N^2) = O(N^4) 。

        2.边长为N的矩阵中正方形的个数数量级是O(N^3)。

        这是因为：在N*N的矩阵中随机抽取一个点的数量级为O(N^2)，随机选取正方形边长数量级为O(N)，即正方形的数量级为O(N^2) * O(N) = O(N^3) 。

        

        有上面的结论我们可以知道在举证中查找正方形的时间复杂度为O（N^3），不能再降低了（其中O(N^2)用于遍历数组中的每一个点，剩下的O(N)用于遍历正方形的边长）。在判断正方形是否都是1时，若使用暴力方法遍历所有点需要O(N)的复杂度，我们这里可以使用预处理的方法进行优化，优化后的复杂度为O(1)。

代码

        首先定义了二维数组rowN和colN长度与原数组长度相同。

        二维数组rowN主要记录该点位置以后（包括该点）行方向上有几个连续的1。

         二维数组colN主要记录该点位置以后（包括该点）列方向上有几个连续的1。

        方法generateRowArr和generateColArr对二维数组rowN和colN进行初始化。初始化二维数组rowN时，从右往左，最右面一列内容与原数组一致，然后前一列判断原来二维数组中是否为1，若是则后一列中的值+1，若不是直接为0。初始化二维数组colN时，从下往上，最下面一列内容与原数组一致，然后上一列判断原来二维数组中是否为1，若是则下一列中的值+1，若不是直接为0。

        方法 isV 功能是用于判断新组成的正方形是否符合要求。若正方形的点位（i,j），边长为k，则只需判断 row[i][j]  col[i][j]  row[i + k-1][j]  col[i][j + k-1]  四个值是否大于或者等于k即可。

public class OneMatrix {

    public static int oneMatrix(int[][] matrix) {
        if (matrix == null || matrix.length == 0) {
            return 0;
        }

        int rowN = matrix.length;
        int colN = matrix[0].length;
        int[][] row = new int[rowN][colN];
        int[][] col = new int[rowN][colN];

        generateRowArr(matrix, row, rowN - 1, colN - 1);
        generateColArr(matrix, col, rowN - 1, colN - 1);

        int max = 1;
        for (int i = 0; i < rowN; i++) {
            for (int j = 0; j < colN; j++) {
                for (int k = 1; k +i-1  < rowN && k+j-1<colN; k++) {
                    if (isV(row, col, i, j, k)) {
                        max = Math.max(max, k);
                    }
                }
            }
        }

        return max;
    }

    private static boolean isV(int[][] row, int[][] col, int i, int j, int k) {
        int rowL = row[i][j];
        int colL = col[i][j];
        int rowLK = row[i + k-1][j];
        int colLK = col[i][j + k-1];

        if (rowL >= k && colL >= k && rowLK >= k && colLK >= k) {
            return true;
        }
        return false;
    }

    private static void generateRowArr(int[][] matrix, int[][] r, int row, int col) {
        for (int i = 0; i <= row; i++) {
            r[i][col] = matrix[i][col] == 1 ? 1 : 0;
        }
        for (int i = 0; i <= row; i++) {
            for (int j = col - 1; j >= 0; j--) {
                r[i][j] = matrix[i][j] == 1 ? 1 + r[i][j + 1] : 0;
            }
        }

    }

    private static void generateColArr(int[][] matrix, int[][] c, int row, int col) {
        for (int i = 0; i <= col; i++) {
            c[row][i] = matrix[row][i] == 1 ? 1 : 0;
        }
        for (int i = row - 1; i >= 0; i--) {
            for (int j = 0; j <= col; j++) {
                c[i][j] = matrix[i][j] == 1 ? 1 + c[i + 1][j] : 0;
            }
        }

    }

    public static void main(String[] args) {
        int[][] arr = new int[][]{
                {0, 1, 1, 1, 1},
                {0, 1, 1, 1, 1},
                {0, 1, 0, 1, 1},
                {0, 1, 1, 1, 1},
                {0, 1, 0, 0, 1}
        };

        System.out.println(oneMatrix(arr));

    }
}