最大正方形

最新推荐文章于 2024-12-14 22:19:31 发布

神山极客

最新推荐文章于 2024-12-14 22:19:31 发布

阅读量118

点赞数

CC 4.0 BY-SA版权

分类专栏：力扣

本文链接：https://blog.youkuaiyun.com/TESE_yan/article/details/114905273

力扣专栏收录该内容

13 篇文章

订阅专栏

力扣地址

暴力遍历：

当找到一个为 1 的值时，以当前点为左上角，取行列值最小的值为边长side_len，

对从1 到 side_len的正方形做判断，每次都先判断当前正方形的对角线，然后再逐个判断周边

class Solution {
public:
    int maximalSquare(vector<vector<char>>& matrix) {
        if (!matrix.size() || !matrix[0].size()) return 0;
        int rows = matrix.size(), cols = matrix[0].size();
        int max_len = 0;
        for (int i = 0; i < rows; ++i) {
            for (int j = 0; j < cols; ++j) {
                if (matrix[i][j] == '1') {
                    max_len = std::max(max_len, 1);
                    int side_len = std::min(rows - i, cols - j);
                    for (int k = 1; k < side_len; ++k) {
                        bool flag = true;
                        if (matrix[i + k][j + k] == '0') {
                            flag = false;
                            break;
                        }
                        for (int m = 0; m < k; ++m) {
                            if (matrix[i + k][j + m] == '0' || matrix[i + m][j + k] == '0') {
                                flag = false;
                                break;
                            }
                        }
                        if (flag) {
                            max_len  = std::max(max_len, k + 1);
                        }
                        else {
                            break;
                        }
                    }
                }
            }
        }
        return max_len * max_len;
    }
};

动态规划：

暴力遍历其实会进行大量重复遍历，其实我们遍历过程中的状态都是可以保存的

状态转移方程： $dp[i][j] = 1$ $(i == 0 or j == 0)$

$dp[i][j] = min(min(dp[i - 1][j], dp[i][j - 1]), dp[i - 1][j - 1]) + 1$ $(i > 0 and j > 0)$

class Solution {
public:
    int maximalSquare(vector<vector<char>>& matrix) {
        if (matrix.empty() || matrix[0].empty()) return 0;
        int rows = matrix.size(), cols = matrix[0].size();
        vector<vector<int>> dp(rows, vector<int>(cols, 0));
        int max_len = 0;
        for (int i = 0; i < rows; ++i) {
            for (int j = 0; j < cols; ++j) {
                if (matrix[i][j] == '1') {
                    if (0 == i || 0 == j) dp[i][j] = 1;
                    else dp[i][j] = min(min(dp[i - 1][j], dp[i][j - 1]),  dp[i - 1][j - 1]) + 1;
                    max_len = max(max_len, dp[i][j]);
                }
            }
        }
        return max_len * max_len;
    }
};