程序员代码面试指南第二版 9.求最大子矩阵的大小(要掌握单调栈结构)

welcome to my blog

程序员代码面试指南第二版 9.求最大子矩阵的大小(要掌握单调栈结构)

题目描述(不含重复值的数组)

题目描述
给定一个整型矩阵 map，其中的值只有 0 和 1 两种，求其中全是 1 的所有矩形区域中，最大的矩形区域里 1 的数量。

输入描述:
第一行输入两个整数 n 和 m，代表 n*m 的矩阵
接下来输入一个 n*m 的矩阵

输出描述:
输出其中全是 1 的所有矩形区域中，最大的矩形区域里 1 的数量。

示例1

输入
1 4
1 1 1 0

输出
3
说明
最大的矩形区域有3个1，所以返回3

第一次做; 时间复杂度O(M*N); 每一行都走一遍单调栈结构(带重复值,但是重复值仍然按照小于的情况处理), 分为两个阶段: 遍历阶段; 清算阶段; 没有左边, 让左边为-1, 这样左边的下一个位置是0, 不影响结果; 没有右边, 让右边为arr.length, 这样右边的前一个位置是arr.length-1; 需要进行单调栈处理的数组height的每个元素的含义是: 以当前位置为底, 往上有多少个连续的1, 包括当前位置, height[j] = matrix[i][j]==1 ? height[j]+1 : 0, 有点动态规划转移方程的感觉

import java.util.Scanner;
import java.util.Stack;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        String curr = sc.nextLine();
        int rows = Integer.valueOf(curr.split(" ")[0]);
        int cols = Integer.valueOf(curr.split(" ")[1]);
        int[][] matrix = new int[rows][cols];
        for(int i=0; i<rows; i++){
            for(int j=0; j<cols; j++){
                matrix[i][j] = Integer.valueOf(sc.nextInt());
            }
        }
        //
        int res = MaxRecArea(matrix);
        System.out.println(res);
    }
    public static int MaxRecArea(int[][] matrix){
        if(matrix==null || matrix.length==0 || matrix[0].length==0)
            return 0;
        //
        int rows = matrix.length;
        int cols = matrix[0].length;
        //每一个元素含义, 以当前索引为底, 向上有多少个连续的1, 包括当前位置
        int[] height = new int[cols];
        int max = 0;
        for(int i=0; i<rows; i++){
            for(int j=0; j<cols; j++){
                height[j] = matrix[i][j] == 1 ? height[j] + 1 : 0;
            }
            max = Math.max(max, monotonicStack(height));
        }
        return max;
    }
    /*
    包含重复元素的单调栈, 但是本题中, 重复元素按照小于的情况处理即可, 之所以这么做, 
    是因为发生重复时, 正确计算其中一个位置的结果即可, 因为这两个对应值相等的索引共享共一个矩形
    如果按照小于的方式处理等于的情况, 会使得两个对应值相等的索引, 弹出靠前的索引计算出的结果偏小
    但是没关系, 弹出靠后的索引能得到正确的结果, 所以就不用对等于的情况进行特殊处理了
    */
    public static int monotonicStack(int[] arr){
        Stack<Integer> s = new Stack<>();
        int max = 0;
        //遍历阶段
        for(int i=0; i<arr.length; i++){
            if(s.isEmpty())
                s.push(i);
            else{
                if(arr[i] > arr[s.peek()])
                    s.push(i);
                else{
                    while(!s.isEmpty() && arr[i] <= arr[s.peek()]){
                        int curr = s.pop();
                        /*
                        矩形面积的计算公式:
                        curr向左可以到达s.peek()+1
                        curr向右可以到达i-1
                        所以矩形面积为: (i-1-(s.peek()+1)+1)*height[i] = (i - 1 - s.peek())*height[i]
                        */
                        //没有左边的时候, 把左边当作-1, 那么左边的下一个位置就是0, 不影响最终结果(这里要想清楚)
                        int newTop = s.isEmpty() ? -1 : s.peek();
                        max = Math.max(max, (i - 1 - newTop)*arr[curr]);
                    }
                    s.push(i);
                }
            }
        }
        
        //清算阶段; 栈顶索引没有右边了, 把右边当作arr.length,  arr.length的前一个位置就是arr.length-1, 不影响最终结果(这里要想清楚)
        while(!s.isEmpty()){
            int curr = s.pop();
            int newTop = s.isEmpty() ? -1 : s.peek();
            max = Math.max(max, (arr.length - 1 - newTop)*arr[curr]);
        }
        return max;
    }
}