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;
     }
 }