944. 删列造序 / 剑指 Offer II 040. 矩阵中最大的矩形

944. 删列造序【简单题】【每日一题】

思路：【模拟】

假设数组中这些字符串从上到下依次排列，而这些字符串的字符从左到右排列，因此这些字符近似以一种矩阵的形式存储。
矩阵的列长就是字符串的长度，矩阵的宽高就是字符串数组的长度，根据字符串在字符串数组中的下标 和字符在字符串中的下标，来精准定位每个字符。

代码：

class Solution {
    public int minDeletionSize(String[] strs) {
        int ans = 0;
        int r = strs.length, c = strs[0].length();
        for (int i = 0; i < c; i++) {
            //遍历所有的列，并求出列首字符为 pre
            char pre = strs[0].charAt(i);
            for (int j = 1; j < r; j++) {
                //从第 1 行开始遍历所有的行，每一行的 第 i 个字符就是第i列的所有值
                char cur = strs[j].charAt(i);
                if (cur < pre){
                    ans++;
                    break;
                }else {
                    pre = cur;
                }
            }
        }
        return ans;
    }
}

---

剑指 Offer II 040. 矩阵中最大的矩形【困难题】

思路：

是剑指 Offer II 039.直方图最大矩形面积的进阶版，比39题多了一层纵向求面积，即将这个矩阵以每一行为底，求直方图的最大矩形面积，遍历每一行，在这个过程中更新最大值。
代码依然来源于yukiyama，属实是把单调栈给玩儿明白了，感谢大佬的分享。

代码 1：【deque】

class Solution {
    public int maximalRectangle(String[] matrix) {
        //如果矩阵为空 则 返回 0
        if (matrix.length == 0){return 0;}
        //记录矩阵的行宽 r 列长 c 能够形成的最大矩形面积 max
        int r = matrix.length,c = matrix[0].length(),max = 0;
        //记录矩阵中以第 i 行元素为底 第 j 列存在1的数量(向上累加，如果第j列元素是0则heights中当前列置为0) 存入一维数组 heights 中
        int[] heights = new int[c];
        for (String s : matrix) {
            for (int j = 0; j < c; j++) {
                //如果矩阵中当前元素是 1 将 heights中对应 j 位置数据 + 1 ; 如果矩阵中当前元素是 0 则将 heights中对应 j 位置数据 置为 0
                heights[j] = s.charAt(j) == '1' ? heights[j] + 1 : 0;
            }
            //将 max 更新为 max 和 以当前行为底 能够形成矩形面积的最大值 这两者之间的最大值
            max = Math.max(max, largestRectangleArea(heights));
        }
        return max;
    }
    public int largestRectangleArea(int[] heights){
        //此时传入参数heights就相当于一个柱状图，我们昨天刚做过给定柱状图求出其能构成的矩形的最大面积
        Deque<Integer> stack = new ArrayDeque<>();
        int n = heights.length,max = 0;
        for (int i = 0; i < n; i++) {//遍历当前行中每一个元素
            //当 栈 不为空 且 当前位置元素 小于 栈顶元素
            while (!stack.isEmpty() && heights[i] < heights[stack.peek()]){
                //取出栈顶元素  并求栈顶元素的高
                int top = stack.pop(),h = heights[top];
                //求栈顶元素的宽
                int w = stack.isEmpty() ? i : i - stack.peek() - 1;
                //计算栈顶元素 top能构成的矩形最大面积，并将其与max进行比较更新
                max = Math.max(max,h * w);
            }
            //当栈为空 或 当前高度 大于栈顶高度 将当前高度对应的下标压入栈
            stack.push(i);
        }
        //高度数组遍历完成之后，栈中可能还剩有元素未处理其能构成的面积，此时矩形右边界一定是n，因此将栈中元素依次取出，求其构成矩形的高和宽，并更新max
        while (!stack.isEmpty()){
            int top = stack.pop(),h = heights[top];
            int w = stack.isEmpty() ? n : n - stack.peek() - 1;
            max = Math.max(max,h * w);
        }
        //此时max即为，传入高度数组能够形成的最大面积
        return max;
    }
}

代码2：【数组模拟】

class Solution {
    public int maximalRectangle(String[] matrix) {
        //如果矩阵为空 则 返回 0
        if (matrix.length == 0){return 0;}
        //记录矩阵的行宽 r 列长 c 能够形成的最大矩形面积 max
        int r = matrix.length,c = matrix[0].length(),max = 0;
        //记录矩阵中以第 i 行元素为底 第 j 列存在1的数量(向上累加，如果第j列元素是0则heights中当前列置为0) 存入一维数组 heights 中
        int[] heights = new int[c];
        for (String s : matrix) {
            for (int j = 0; j < c; j++) {
                //如果矩阵中当前元素是 1 将 heights中对应 j 位置数据 + 1 ; 如果矩阵中当前元素是 0 则将 heights中对应 j 位置数据 置为 0
                heights[j] = s.charAt(j) == '1' ? heights[j] + 1 : 0;
            }
            //将 max 更新为 max 和 以当前行为底 能够形成矩形面积的最大值 这两者之间的最大值
            max = Math.max(max, largestRectangleArea(heights));
        }
        return max;
    }
    public int largestRectangleArea(int[] heights){
        //此时传入参数heights就相当于一个柱状图，我们昨天刚做过给定柱状图求出其能构成的矩形的最大面积
        int n = heights.length,max = 0,top = -1;
        int[] stack = new int[n];
        for (int i = 0; i < n; i++) {//遍历当前行中每一个元素
            //当 栈 不为空 且 当前位置元素 小于 栈顶元素
            while (top != -1 && heights[i] < heights[stack[top]]){
                //取出栈顶元素  并求栈顶元素的高
                int h = heights[stack[top--]];
                //求栈顶元素的宽
                int w = top == -1 ? i : i - stack[top] - 1;
                //计算栈顶元素 top能构成的矩形最大面积，并将其与max进行比较更新
                max = Math.max(max,h * w);
            }
            //当栈为空 或 当前高度 大于栈顶高度 将当前高度对应的下标压入栈
            stack[++top] = i;
        }
        //高度数组遍历完成之后，栈中可能还剩有元素未处理其能构成的面积，此时矩形右边界一定是n，因此将栈中元素依次取出，求其构成矩形的高和宽，并更新max
        while (top != -1){
            int h = heights[stack[top--]];
            int w = top == -1 ? n : n - stack[top] - 1;
            max = Math.max(max,h * w);
        }
        //此时max即为，传入高度数组能够形成的最大面积
        return max;
    }
}