#1139 Largest 1-Bordered Square

Description

Given a 2D grid of 0s and 1s, return the number of elements in the largest square subgrid that has all 1s on its border, or 0 if such a subgrid doesn’t exist in the grid.

Examples

Example 1:

Input: grid = [[1,1,1],[1,0,1],[1,1,1]]
Output: 9

Example 2:

Input: grid = [[1,1,0,0]]
Output: 1

Constraints:

1 <= grid.length <= 100
1 <= grid[0].length <= 100
grid[i][j] is 0 or 1

思路

是一个dp的思路，构建4个矩阵，分别用来表示对当前节点 grid[i][j]，其上/下/左/右分别有多少连续的1
然后对于grid中的每个元素，判断他能组成的最大square

代码

class Solution {
    public int largest1BorderedSquare(int[][] grid) {
        int n = grid.length;
        int m = grid[0].length;
        
        int[][] dpUp = new int[n][m];
        int[][] dpDown = new int[n][m];
        int[][] dpRight = new int[n][m];
        int[][] dpLeft = new int[n][m];
        
        // update left
        for (int i = 0; i < n; i++) {
            dpLeft[i][0] = grid[i][0];
            for (int j = 1; j < m; j++){
                dpLeft[i][j] = grid[i][j] == 0? 0: dpLeft[i][j - 1] + 1;
            }
        }
        // update right
        for (int i = 0; i < n; i++) {
            dpRight[i][m - 1] = grid[i][m - 1];
            for (int j = m - 2; j >= 0; j--) {
                dpRight[i][j] = grid[i][j] == 0? 0: dpRight[i][j + 1] + 1;
            }
        }
        // update up
        for (int i = 0; i < m ; i++) {
            dpUp[0][i] = grid[0][i];
            for (int j = 1; j < n; j++) {
                dpUp[j][i] = grid[j][i] == 0? 0: dpUp[j - 1][i] + 1;
            }
        }
        // update down
        for (int i = 0; i < m; i++) {
            dpDown[n - 1][i] = grid[n - 1][i];
            for (int j = n - 2; j >= 0; j--) {
                dpDown[j][i] = grid[j][i] == 0? 0: dpDown[j + 1][i] + 1;
            }
        }
        
        // start dp
        int max = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                int tmpMax = Math.min(dpRight[i][j], dpDown[i][j]);
                for (int k = tmpMax - 1; k >= 0; k--) {
                    if (i + k < n && j + k < m && dpLeft[i + k][j + k] > k && dpUp[i + k][j + k] > k){
                        max = Math.max(max, (k + 1) * (k + 1));
                        break;
                    }
                }
            }
        }
        
        return max;
    }
}