【力扣-LeetCode】1139. 最大的以 1 为边界的正方形 C++题解

最新推荐文章于 2023-02-19 21:18:39 发布

Vorüarn0362

最新推荐文章于 2023-02-19 21:18:39 发布

阅读量669

点赞数

CC 4.0 BY-SA版权

分类专栏： LeetCode C/C++ 数据结构文章标签： c++

本文链接：https://blog.csdn.net/Sgappti/article/details/129081520

C/C++ 同时被 3 个专栏收录

16 篇文章

订阅专栏

LeetCode

13 篇文章

订阅专栏

数据结构

4 篇文章

订阅专栏

给定一个由0和1组成的二维网格，找到边界全由1构成的最大正方形子网格，返回其元素数量。算法通过扫描每个子网格的周长来确定最大正方形。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

难度中等137收藏分享切换为英文接收动态反馈

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

解题思路：以正方形周长的路径扫描每个子网格；

以当前坐标(i,j)为起点，L为边长，扫描一个正方形的周长，判断是否构成一个正方形，并不断更新maxL（当前的最大边长）；

最后返回maxL*maxL即可。

AC代码：

class Solution {
public:

    bool hasSquare(int SI,int SJ,int L,vector<vector<int>>& grid){
        // 扫描顺序：上、右、下、左
        for(int k=0;k<4;k++){
            if(k==0){//上边
                for(int m=0;m<L;m++){
                    if(SJ<0 || SJ>=grid[0].size())
                        return false;
                    if(grid[SI][SJ]!=1)
                        return false;
                    if(m<L-1)
                        SJ++;
                }
            }
            if(k==1){//右边
                for(int m=0;m<L;m++){
                    if(SI<0 || SI>=grid.size())
                        return false;
                     if(grid[SI][SJ]!=1)
                        return false;
                    if(m<L-1)
                        SI++;
                }
            }
            if(k==2){//下边
                for(int m=0;m<L;m++){
                    if(SJ<0 || SJ>=grid[0].size())
                        return false;
                     if(grid[SI][SJ]!=1)
                        return false;
                    if(m<L-1)
                        SJ--;
                }
            }
            if(k==3){//左边
                for(int m=0;m<L;m++){
                    if(SI<0 || SI>=grid.size())
                        return false;
                     if(grid[SI][SJ]!=1)
                        return false;
                    if(m<L-1)
                        SI--;
                }
            } 
        }
        return true;
    }

    int largest1BorderedSquare(vector<vector<int>>& grid) {
        if(grid.size()==1){
            for(int i=0;i<grid[0].size();i++){
                if(grid[0][i]==1)
                    return 1;
            }
            return 0;
        }
        //解题思路：以正方形周长的路径扫描每个子网格
        int maxL=0;
        int row=grid.size();    //行数
        int col=grid[0].size(); //列数

        for(int i=0;i<row;i++){
            
            for(int j=0;j<col;j++){
                if(grid[i][j]!=1)
                    continue;

                int L=max(maxL,1);
                //以当前坐标(i,j)为起点，L为边长，扫描一个正方形的周长
                //判断是否构成一个正方形
                int LLen=min(row-i,col-j);
                bool isOk=false;
                for(;L<=LLen;L++){
                    isOk=hasSquare(i,j,L,grid);
                    if(isOk)
                        maxL=max(L,maxL);
                } 
            }
        }
        return maxL*maxL;
    }
};