单调栈结构问题-求最大子矩阵

最新推荐文章于 2022-08-23 15:23:32 发布

原创最新推荐文章于 2022-08-23 15:23:32 发布 · 315 阅读

0 ·

CC 4.0 BY-SA版权

算法专栏收录该内容

13 篇文章

订阅专栏

博客介绍了求矩形最大面积问题的解决思路。先分割每一行，统计以当前行作底时每个位置向上1的数量，将问题转化为求每个数组组成矩形的最大面积。给出了暴力解法，时间复杂度为O(n^2)，还介绍了用单调栈结构、时间复杂度为O(n)的算法，并给出代码实现示例。

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

题目描述
Given a 2D binary matrix filled with 0's and 1's, find the largest rectangle containing only 1's and return its area.

For example, given the following matrix:

1 0 1 0 0
1 0 1 1 1
1 1 1 1 1
1 0 0 1 0
Return 6.

1.接替思路
分割每一行，统计以当前行作为底的情况下的每个位置向上1的数量
如：分割第一行结果为 [1，0，1，0，0]
第二行为[2,0,2,1,1]第三行为[3,1,3,2,2]最后一行为[4,1,0,3,0]
代码实现如下

public int[] maxFromBottom(int[][] arr){
        int[] bottom = new int[arr[0].length];
        for(int i = 0; i < arr.length; i++){
            for(int j = 0; j < arr[0].length; j++){
                bottom[j] = arr[i][j] == 0 ? 0 : bottom[j] + 1;
            }
        }
        return bottom;
    }

2.此时该问题就是求每个数组组成的矩形的最大面积，这个问题可以采用暴力解法，每遍历到一个柱高后向前找能形成的最大面积，时间复杂度为O(n^2)代码实现如下

 public int largestRectangleArea(int[] arr) {
        if(arr.length == 0) return 0;
        int res = 0;
        for(int i = 0; i < arr.length; i++){
        柱高向右可以扩展的最大坐标，
            if(i + 1 < arr.length && arr[i] < arr[i+1]){
                continue;
            } 
            //当发现arr[i] > arr[i+1] 结束扩展，开始寻找最大面积
            //每个在i之前的柱高*该柱到i的距离 为该柱形成的面积
                int high = arr[i];
                for(int j = i; j >= 0; j--){
                    high = Math.min(arr[j], high);
                    int tmp = high * (i-j+1);
                    res = Math.max(res, tmp);
                } 
        }
        return res;
    }

用时间复杂度为O(n)的算法，用到单调栈结构。相比于暴力法单调栈直接记录了寻找最大面积中的遍历过程。对每个元素push一次，pop一次，在pop的过程中拿到该阶段最大值。如[2,3,4,3,5] 先压如index 0值为2,index=1时，arr[1] > arr[0]继续压入此时栈为【1，0】，继续压入4的index为【2，1，0】，当碰到index为3时，arr[3] < arr[2] 此时2弹出，arr[2]=4柱高为4，向右扩展时为3，无法扩展，向左扩展为3无法扩展，则index=2扩展出的面积为4左右两边扩展的边界*高度，此时相当于暴力法中i = 2，j=2所算出的第一个面积，再弹出1，arr[1]=3重复上述过程。代码实现如下：

public int maxSize(int[] arr){
        if(arr == null || arr.length == 0) return 0;
        int maxSize = 0;
        Stack<Integer> stack = new Stack<>();
        for(int i = 0; i < arr.length; i++){
            while(!stack.isEmpty() && arr[stack.peek()] > arr[i]){
                int popIndex = stack.pop();
                int dis = stack.isEmpty()? -1 : stack.peek();
                int curSize = arr[popIndex]*(i-dis-1);
                maxSize = Math.max(curSize, maxSize);
            }
            stack.push(i);
        }
        //最后形成一个单调栈则栈中的值需要pop出计算面积。
        while(!stack.isEmpty()){
            int popIndex = stack.pop();
            int dis = stack.isEmpty()? -1 : stack.peek();
            int curSize = arr[popIndex]*(arr.length-dis-1);
            maxSize = Math.max(curSize, maxSize);
        }
        return maxSize;
    }