leetcode221.最大正方形（中等）

思路一：暴力
具体思路： 依次遍历每个元素，以该元素为左上角元素，依次在下面和右面扩张一行，直到出现’0’的元素
易错点： 增加行的时候矩阵注意不要越界！！！

class Solution {
public:
    int maximalSquare(vector<vector<char>>& matrix) {
        //暴力
        int ans = 0;
        int m = matrix.size(), n = matrix[0].size();
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (matrix[i][j] == '1') {
                    ans = max(ans, 1);
                    int tmp = 1;
                    while (i + tmp < m && j + tmp < n) {
                        int flag = false; //没有0
                        for (int k = j; k <= j + tmp && !flag; ++k) {
                            if (matrix[i + tmp][k] == '0') flag = true;
                        }
                        for (int k = i; k <= i + tmp && !flag; ++k) {
                            if (matrix[k][j + tmp] == '0') flag = true;
                        }
                        if (!flag) {
                            ans = max(ans, tmp + 1);
                        }else break; //如果扩张后出现了'0'，则直接退出循环，遍历下一个元素
                        tmp++;
                    }
                }
            }
        }
        return ans * ans;

    }
};

思路二：单调栈
维护一个单调递增栈，不是到左边第一个小于的位置，而是分别到两边第一个小于它的位置。

class Solution {
public: 
    void get_l(vector<int>& l, vector<int>& r, vector<int>& height) {
        int m = height.size();
        vector<int> stk(m);
        int top = -1;
        for (int i = 0; i < m; ++i) {
            
            while (top != -1 && height[stk[top]] >= height[i]) {
                --top;
            }
            if (top != -1) l[i] = stk[top];
            stk[++top] = i;
        }
        top = -1;
        for (int i = m - 1; i >= 0; --i) {
            while (top != -1 && height[stk[top]] >= height[i]) {
                --top;
            }
            if (top != -1) r[i] = stk[top];
            stk[++top] = i;
        }
    }
    int maximalSquare(vector<vector<char>>& matrix) {

        int n = matrix.size(), m = matrix[0].size(), ans = 0;
        vector<int> height(m);
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                if (matrix[i][j] == '1') height[j]++;
                else height[j] = 0; //
            }
            vector<int> l(m, -1), r(m, m);
            get_l(l, r, height);
            for (int k = 0; k < m; ++k) {
                ans = max(ans, min(r[k] - l[k] - 1, height[k]));
            }
        }
        return ans * ans;
    }
};

易错点：当matrix[i][j] == '0’时 height[i][j] == 0
思路三：动态规划
思路来源： 以matrix[i][j]为右下角，如果最大的正方形边长为m，则 以matrix[i][j-1] matrix[i-1][j] matrix[i-1][j-1]为右下角的最大正方形边长至少为 m-1。
因此：
设：dp[i][j]表示以matris[i][j]为右下角元素的最大正方形边长
状态转移方程为dp[i][j] = min(dp[i][j-1],dp[i-1][j],dp[i-1][j-1])+1;
边界为：dp[i][j]=matrix[i][j]-‘0’;

class Solution {
public:
    int maximalSquare(vector<vector<char>>& matrix) {
		//动态规划
        int m = matrix.size(), n = matrix[0].size();
        vector<vector<int>> dp(m, vector<int>(n));
        int ans = 0;
        for (int i = 0; i < m; ++i) {
            dp[i][0] = matrix[i][0] - '0';
            ans = max(ans, dp[i][0]);
        }
        for (int j = 0; j < n; ++j) {
            dp[0][j] = matrix[0][j] - '0';
            ans = max(ans, dp[0][j]);
        }
        for (int i = 1; i < m; ++i) {
            for (int j = 1; j < n; ++j) {
                if (matrix[i][j] == '1') {
                    dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;
                    ans = max(ans, dp[i][j]);
                }
            }
        }
        return ans * ans;
    }
};