LeetCode 1139. 最大的以 1 为边界的正方形--动态规划

1139. 最大的以 1 为边界的正方形

给你一个由若干 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

题解

和这个题目基本一致，只是要求变成了只需要边缘都是1即可，在上一个题目中，如果遇到内部不为1的情况就马上结束循环，现在我们的判断修改成一直循环判断下去即可。

AC代码

class Solution {
public:
    int dp[105][105][4];
    int largest1BorderedSquare(vector<vector<int>>& grid) {
        memset(dp,0,sizeof(dp));
        for(int i=grid.size()-1;i>=0;i--)
        {
            for(int j=grid[i].size()-1;j>=0;j--)
            {
                if(grid[i][j]==1)
                {
                    dp[i+1][j+1][0]=dp[i+1][j+2][0]+1;
                    dp[i+1][j+1][1]=dp[i+2][j+1][1]+1;
                }
            }
        }
        for(int i=0;i<grid.size();i++)
        {
            for(int j=0;j<grid[i].size();j++)
            {
                if(grid[i][j]==1)
                {
                    dp[i+1][j+1][2]=dp[i+1][j][2]+1;
                    dp[i+1][j+1][3]=dp[i][j+1][3]+1;
                }
            }
        }
        int mx=0;
        for(int i=1;i<=grid.size();i++)
        {
            for(int j=1;j<=grid[i-1].size();j++)
            {
                for(int k=0;k<=900;k++)
                {
                    if(i+k>grid.size()||j+k>grid[i-1].size())break;
                    if(dp[i][j][0]>=(k+1)&&dp[i][j][1]>=(k+1)&&dp[i+k][j+k][2]>=(k+1)&&dp[i+k][j+k][3]>=(k+1))
                    mx=max(mx,k+1);
                }
            }
        }
        return mx*mx;
    }
};