leetCode1139——最大的以 1 为边界的正方形

每日一题 leetCode，今天是 leetCode1139,属于中等难度题目，核心思想就是预处理优化，算法比较容易想到，偏暴力循环求解。

题目：

给你一个由若干 0 和 1 组成的二维网格 grid，请你找出边界全部由 1 组成的最大 正方形 子网格，并返回该子网格中的元素数量。如果不存在，则返回 0。

示例 1：

输入：grid = [[1,1,1],[1,0,1],[1,1,1]]
输出：9
示例 2：

输入：grid = [[1,1,0,0]]
输出：1
 

提示：

1 <= grid.length <= 100
1 <= grid[0].length <= 100
grid[i][j] 为 0 或 1

解析：对于一个任意二维数组，想要构成正方形，时间复杂度一定是 O(N^3)级别，对于任意一个点（i, j），构造边长为 border 大小的正方形，判断该正方形是否符合边界全为0的要求，如果满足，则记录下；如果不满足，则继续循环。但是会存在两个个问题，第一个问题是，如果 border 每一次都是从 0 开始到 Math.min(grid.length, grid[0].length)范围，会出现某一个点满足条件，但是不是全局最优解；第二个问题后文阐。

所以，更好的方法是最外层循环用 border 从 Math.min(grid.length, grid[0].length)到0，依次递减，内保是点的循环，意义是：按照边长最大获取，如果可以构成正方形，立即结束，表述可以满足；如果不能构成正方形，位置点继续往下，然后边长减小。这样，返回的结果就是找到的最小的，满足题目要求

总体框架：

for (int border = Math.min(grid.length, grid[0].length); border > 0; border--) {
    for (int i = 0; i + border - 1 < m; i++) {
        for (int j = 0; j + border - 1 < n; j++) {
            // 以 i，j 点为左上角顶点，border 为边长大小，构成的正方形
            if (该正方形满足条件) {
                return border * border;
            }
        }
    }
}

那么问题来了，怎么判断“该正方形是否满足条件”呢？

是写循环判断？——时间复杂度到了 O(N^4)，可以通过测试点，但是，不是最优的解决方法

——很简单，对于四个正方形顶点来说，只要顶点4条边1的数量等于边长（border），则说明该正方形满足条件。那么，我们可以想到，左上顶点向右1的长度等于边长border；左上顶点向下1的长度等于边长border；右上顶点向下1的长度等于边长border；左下顶点向右1的长度等于边长border；如果满足4个条件，则说明已经撑到最大了！因为 border 是递减的，有点小小的贪心意思在里面。

你有没有发现，只需要统计每个顶点向下和向右的1的个数即可。问题又来了，怎么去统计每个顶点有几个向下的1，几个向右的1？——当然可以在之前进行统计预处理！时间复杂度为 O(N^2)，我们需要定义两个二维数组

int m = grid.length;
int n = grid[0].length;

// 生成向右存储数组
int[][] rightStore = new int[m][n];
// 生成向下存储数组
int[][] downStore = new int[m][n];

对于右边1的统计，规则是：如果该位置为0，则向右一定为0个；如果该位置为1，但是是最后一个位置，那么，该位置一定为1；如果该位置为1，并且不是最后一个，那么，该位置等于该位置的右边一个位置统计的结果加1！向下的1统计方法也是同样的道理。是不是有点动态规划的意思了！

代码如下：

// 生成右数据
for (int i = 0; i < m; i++) {
    for (int j = n - 1; j >= 0; j--) {
        if (grid[i][j] == 0) {
            rightStore[i][j] = 0;
        } else {
            if (j == n - 1) {
                rightStore[i][j] = 1;
            } else {
                rightStore[i][j] = rightStore[i][j + 1] + 1;
            }
        }
    }
}


// 生成下数据
for (int i = m - 1; i >= 0; i--) {
    for (int j = 0; j < n; j++) {
        if (grid[i][j] == 0) {
            downStore[i][j] = 0;
        } else {
            if (i == m - 1) {
                downStore[i][j] = 1;
            } else {
                downStore[i][j] = downStore[i + 1][j] + 1;
            }
        }
    }
}

如此一来，if 中“该正方形满足条件”可以得到：

if (左上角向下的1大于等于 border

        && 左上角向右的1大于等于 border

        && 右上角向下的1大于等于 border

        && 左下角向右的1大于等于 border

)

代码：

if (downStore[i][j] >= border
        && rightStore[i][j] >= border
        && downStore[i][j + border- 1] >= border
        && rightStore[i + border - 1][j] >= border

)

核心代码大功告成！

所有代码：

public static int largest1BorderedSquare(int[][] grid) {
    if (grid == null || grid.length == 0) {
        return 0;
    }
    int m = grid.length;
    int n = grid[0].length;
    // 生成向右存储数组
    int[][] rightStore = new int[m][n];
    // 生成向下存储数组
    int[][] downStore = new int[m][n];
    int ans = 0;

    // 生成右数据
    for (int i = 0; i < m; i++) {
        for (int j = n - 1; j >= 0; j--) {
            if (grid[i][j] == 0) {
                rightStore[i][j] = 0;
            } else {
                if (j == n - 1) {
                    rightStore[i][j] = 1;
                } else {
                    rightStore[i][j] = rightStore[i][j + 1] + 1;
                }
            }
        }
    }


    // 生成下数据
    for (int i = m - 1; i >= 0; i--) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] == 0) {
                downStore[i][j] = 0;
            } else {
                if (i == m - 1) {
                    downStore[i][j] = 1;
                } else {
                    downStore[i][j] = downStore[i + 1][j] + 1;
                }
            }
        }
    }

    // 以 border 为边长 i j 位置为顶点，想右下延伸
    for (int border = Math.min(grid.length, grid[0].length); border > 0; border--) {
        for (int i = 0; i + border - 1 < m; i++) {
            for (int j = 0; j + border - 1 < n; j++) {
                if (downStore[i][j] >= border && rightStore[i][j] >= border
                    && downStore[i][j + border - 1] >= border && rightStore[i + border - 1][j] >= border) {
                    return border * border;
                }
            }
        }
    }
    
    return 0;
}

还有一个遗留问题，也是笔者一开始错误的原因！为啥我用这样的 for 循环就不行呢？

        int ans = 0;

        // 以 i j 位置为顶点，想右下延伸

        for (int i = 0; i < m; i++) {

            for (int j = 0; j < n; j++) {

                for (int border = 1; border <= Math.min(n - j, m - i); border++) {

                    // 边长为 border 大小

                    int curMax = Math.min(

                            Math.min(downStore[i][j], rightStore[i][j])

                            , Math.min(downStore[i][j + border - 1], rightStore[i + border - 1][j])

                    );

                    ans = Math.max(ans, Math.min(curMax, border));

                }

            }

        }

这个是笔者之前错误的写法，我用的是先从点 （i, j）开始，边长从小到大尝试，看看每个点最多的 1 的数量，三个点去最小的。听起来是不是很有道理？实际上这个算法不行！虽然我这个只有3个测试点没过，但是，大概率是因为 leetCode 对于这个测试有点“水”，我们来看一组数据

                 {1,0,1,1,1,1,1,1}
                ,{0,0,1,1,0,1,1,0}
                ,{0,1,1,0,0,1,1,0}
                ,{1,0,1,0,1,1,1,1}
                ,{1,1,1,1,1,1,0,1}
                ,{0,1,1,1,1,1,1,0}
                ,{0,1,1,1,1,1,1,1}

就是这组二维数组，我们看看 grid[0][2]这个位置的1，最大可以构成边长为多少的正方形？当然是2！而按照 border 从0开始增大的算法结果是4！因为，他取了最小的是4，但是忽略了，在4的条件下是无法构成正方形的！这个点，不给这个测试用例，笔者真没想到，完全属于逻辑漏洞！

总结：本题不是一道很难想的题目，就算是用 O(N^4) 的算法一样可以过测试点，具有启发性的思考是用动态规划的思想进行预存储，这样我每次判断的时候时间复杂度都是 O(1)~!