单调栈问题汇总

目录

• 单调栈(Monotone Stack)
• 42. 接雨水
• 84. 柱状图中最大的矩形
• 方法1：暴力法O(n^2)
• 方法2：单调栈O(n)
• 单调栈：不使用Stack，使用Deque
• 方法3：暴力优化（本题最优解）

单调栈(Monotone Stack)

栈的应用中有一类问题称为单调栈(Monotone Stack)问题，可以巧妙的将某些问题的时间复杂度降到「O(n)级别」。那么什么是单调栈呢？

所谓单调栈，就是保持栈中的元素是单调的。假设把数组 [2 1 4 6 5]依次入栈，并保持栈的单调递增性，如下：

1. 元素2入栈，此时栈中元素为[2]
2. 元素1入栈，由于此时1小于栈顶元素2，把1入栈的话就不满足单调递增性了，于是先把栈顶元素2弹出，再让元素1入栈，此时栈中元素为[1]
3. 元素4入栈，由于此时4大于栈顶元素1，可以满足递增性，故入栈，此时栈中元素为[1,4]
4. 元素6入栈，同上，此时栈中元素为[1,4,6]
5. 元素5入栈，同第2步，在入栈前先把栈顶元素6弹出，故此时栈中元素为[1,4,5]

由于栈中元素(从栈底至栈顶)保持单调递增性，因此，有这样一个性质：

假设当前元素为a，栈顶元素（若栈非空）就是元素a左侧第一个小于a的元素

同样的，如果维护一个单调递减栈，那么就有：

假设当前元素为a，栈顶元素（若栈非空）就是元素a左侧第一个大于a的元素

下面就来看一下单调栈的应用。

42. 接雨水

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。

分析：本题是单调栈的典型应用。首先，我们考虑该选取单调递减栈还是单调递增栈？

由于要接到雨水，显然，必须要形成“凹”的形状，由此可以确定，应当是选取递减栈——按递减的序列把高度存进去（递减指的是从栈底至栈顶递减），一旦发现当前的高度大于栈顶元素了，说明形成了凹槽。但是计算凹槽的面积，除了高度，还需要知道宽度，因此，我们应该在栈中存放下标而非直接存放高度。

class Solution {    
    public int trap(int[] height) {
        int n = height.length;
        int total = 0; // 能接到的雨水总量
        Stack<Integer> s = new Stack<>(); // 存放数组下标，而非数组元素
        int i = 0;
        while(i < n) {
            // 维护一个单调递减栈
            if(s.isEmpty() || height[i] < height[s.peek()]) {
                s.push(i);
                i++;
            }else {
                int bottom = s.pop();
                if(s.isEmpty()) continue; // 关键
                int w = i - s.peek() - 1;
                int h = Math.min(height[s.peek()], height[i]) - height[bottom];
                total += w * h;
            }
        }
        return total;
    }
}

84. 柱状图中最大的矩形

方法1：暴力法O(n^2)

算法思路：
从最基础的思路出发，已知矩形面积的计算公式为：高度 × 宽度。就本题而言，每个小矩形的高度是确定，我们可以固定一个小矩形i，以heights[i]为高度，以位置 i 为中心向左右两侧扩散，使得扩展到的柱子的高度均不小于 h，直到到达边界、或者不能再向外延伸了。
换句话说，我们需要找到左右两侧最近的高度小于 h 的柱子，这样这两根柱子之间（不包括其本身）的所有柱子高度均不小于 h，并且就是 i 能够扩展到的最远范围。

这种做法的时间复杂度是O(n^2)，因为遍历数组需要O(n)，固定位置i向两侧延伸时最大也需要O(n)，即两层for循环。

class Solution {
    /*
    暴力解法
    时间复杂度：O(n^2)
    空间复杂度：O(1)
    */
    public int largestRectangleArea(int[] heights) {
        int maxArea = 0;
        for(int i = 0; i < heights.length; i++) {
            int h = heights[i];
            int left = i, right = i;
            while(left >= 0 && heights[left] >= h) left--;
            while(right < heights.length && heights[right] >= h) right++;
            int w = right - left - 1;
            maxArea = Math.max(maxArea, w * h);
        }
        return maxArea;
    }
}

方法2：单调栈O(n)

class Solution {
    public int largestRectangleArea(int[] heights) {
        // 预处理：添加哨兵
        int n = heights.length;
        int[] temp = new int[n + 1];
        for(int i = 0; i < n; i++) {
            temp[i] = heights[i];
        }
        temp[n] = 0;// 哨兵
        heights = temp;
        // 正式处理
        Stack<Integer> s = new Stack<>();
        int maxArea = 0, i = 0;
        while(i < heights.length) {
            if(s.isEmpty() || heights[i] >= heights[s.peek()]) {
                s.push(i);
                i++;
            }else{
                int t = s.pop();
                if(s.isEmpty()) {
                    maxArea = Math.max(maxArea, i * heights[t]);
                }else {
                    maxArea = Math.max(maxArea, (i - s.peek() - 1) * heights[t]);
                }
            }
        }
        return maxArea;
    }
}

单调栈：不使用Stack，使用Deque

使用双端队列来模拟栈，速度更快一些。因为在Java中，Stack其实不推荐使用的。

class Solution {
    public int largestRectangleArea(int[] heights) {
        // 预处理：添加哨兵
        int n = heights.length;
        int[] temp = new int[n + 1];
        for(int i = 0; i < n; i++) {
            temp[i] = heights[i];
        }
        temp[n] = 0;// 哨兵
        heights = temp;
        // 正式处理
        Deque<Integer> s = new LinkedList<>();
        int maxArea = 0, i = 0;
        while(i < heights.length) {
            if(s.isEmpty() || heights[i] >= heights[s.peekLast()]) {
                s.add(i);
                i++;
            }else{
                int t = s.pollLast();
                if(s.isEmpty()) {
                    maxArea = Math.max(maxArea, i * heights[t]);
                }else {
                    maxArea = Math.max(maxArea, (i - s.peekLast() - 1) * heights[t]);
                }
            }
        }
        return maxArea;
    }
}

方法3：暴力优化（本题最优解）

class Solution {
    public int largestRectangleArea(int[] heights) {
        if(heights.length == 0) return 0;

        int maxArea = 0;
        int n = heights.length;
        /*
        left[i]  表示位置i左侧第一个小于heights[i]的位置
        right[i] 表示位置i右侧第一个小于heights[i]的位置
        */
        int[] left = new int[n];
        int[] right = new int[n];
        left[0] = -1;
        for(int i = 1; i < n; i++) {
            int k = i-1;
            while(k >= 0 && heights[k] >= heights[i]) {
                // k--;
                k = left[k];
            }
            left[i] = k;
        }

        right[n-1] = n;
        for(int i = n-2; i >= 0; i--) {
            int k = i+1;
            while(k < n && heights[k] >= heights[i]) {
                // k++;
                k = right[k];
            }
            right[i] = k;
        }

        /*
        计算面积
        对于高度为heights[i]的柱子，以其为中心可以形成的最大矩形面积等于
        heights[i] × (right[i] - left[i] - 1)
        */
        for(int i = 0; i < n; i++) {
            int currArea = heights[i] * (right[i] - left[i] - 1);
            maxArea = Math.max(maxArea, currArea);
        }
        return maxArea;
    }
}