LeetCode 1139. Largest 1-Bordered Square

原题链接在这里：https://leetcode.com/problems/largest-1-bordered-square/

题目：

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.

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

题解：

For each cell in the grid, calculate its farest reach on top and left direction.

Then starting from l = Math.min(grid.length, grid[0].length) to l = 1, iterate grid to check if square with boarder l exist. If it does return l*l.

Time Complexity: O(m*n*(min(m,n))). m = grid.length. n = grid[0].length.

Space: O(m*n).

AC Java:

class Solution {
    public int largest1BorderedSquare(int[][] grid) {
        if(grid == null || grid.length == 0 || grid[0].length == 0){
            return 0;
        }
        
        int m = grid.length;
        int n = grid[0].length;
        int [][] top = new int[m][n];
        int [][] left = new int[m][n];
        for(int i = 0; i<m; i++){
            for(int j = 0; j<n; j++){
                if(grid[i][j] > 0){
                    top[i][j] = i == 0 ? 1 : top[i-1][j]+1;
                    left[i][j] = j == 0 ? 1 : left[i][j-1]+1;
                }
            }
        }
        
        for(int l = Math.min(m, n); l>0; l--){
            for(int i = 0; i+l-1<m; i++){
                for(int j = 0; j+l-1<n; j++){
                    if(top[i+l-1][j] >= l 
                        && top[i+l-1][j+l-1] >= l
                        && left[i][j+l-1] >= l
                        && left[i+l-1][j+l-1] >= l){
                        return l*l;
                    }
                }
            }
        }
        
        return 0;
    }
}

Or after get top and left.

Iterate the grid, for each cell, get small = min(top[i][j], left[i][j]).

All l = small to 1 could be protential square boarder. But we only need to check small larger than global longest boarder since we only care about the largest.

Check top of grid[i][j-small+1] and left of grid[i-small+1][j]. If they are both larger than small, then it is a grid.

Time Complexity: O(n^3).

Space: O(n^2).

AC Java:

class Solution {
    public int largest1BorderedSquare(int[][] grid) {
        if(grid == null || grid.length == 0 || grid[0].length == 0){
            return 0;
        }
        
        int m = grid.length;
        int n = grid[0].length;
        int [][] top = new int[m][n];
        int [][] left = new int[m][n];
        for(int i = 0; i<m; i++){
            for(int j = 0; j<n; j++){
                if(grid[i][j] > 0){
                    top[i][j] = i == 0 ? 1 : top[i-1][j]+1;
                    left[i][j] = j == 0 ? 1 : left[i][j-1]+1;
                }
            }
        }
        
        int res = 0;
        
        for(int i = m-1; i>=0; i--){
            for(int j = n-1; j>=0; j--){
                int small = Math.min(top[i][j], left[i][j]);
                while(small > res){
                    if(top[i][j-small+1] >= small && left[i-small+1][j] >= small){
                        res = small;
                        break;
                    }
                    
                    small--;
                }
            }
        }
        
        return res*res;
    }
}