代码随想录算法训练营day64 || 84. 柱状图中最大的矩形

 单调栈，又一次经典来袭！ LeetCode：84.柱状图中最大的矩形_哔哩哔哩_bilibili

首先补充昨天接雨水题目解法的更新，代码随想录 中给出双指针和单调栈的解法，其中所采用的思想是计算每一列可以容纳的雨水，非常的关键，是指导双指针的重要思想。双指针的核心思路是对于每一列，其所容纳的雨水量必定取决于左右两

侧的最高高度，即每一列考虑自身是出于山谷的中间还是两边；这是所有可以容纳雨水的情况；山峰的情况是必定容纳不了雨水的。

而双指针的优化是使用了数组存储各个位置所记录的单边最大高度，有一点动态规划的思想。双指针的求解思路非常的厉害；单调栈也是延续这一个思想，栈内以递增的顺序进行元素的存储。其中出现大于栈顶的元素height[i]，再结合栈内一定是栈顶往下递增的，所以此时出现了山谷，那么需要仍然按照列可容纳的思路进行雨水量的累加。

// 减去height[mid]就是所谓的减去高度差的思想
int h = Math.min(height[left], height[index]) - height[mid];
// 计算间隔
int w = index - left - 1;
// 计算剔除了高度差后，目前出栈列与当前i之间可以填入的雨水量
int hold = h * w;
if (hold > 0) sum += hold;
    stackTop = stack.peek();

// 双指针解法真的太厉害了，我个人觉得比单调栈来的神

class Solution {
    public int trap(int[] height) {
        int length = height.length;
        if (length <= 2) return 0;
        int[] maxLeft = new int[length];
        int[] maxRight = new int[length];

        // 记录每个柱子左边柱子最大高度
        maxLeft[0] = height[0];
        for (int i = 1; i< length; i++) maxLeft[i] = Math.max(height[i], maxLeft[i-1]);

        // 记录每个柱子右边柱子最大高度
        maxRight[length - 1] = height[length - 1];
        for(int i = length - 2; i >= 0; i--) maxRight[i] = Math.max(height[i], maxRight[i+1]);

        // 求和
        int sum = 0;
        for (int i = 0; i < length; i++) {
            int count = Math.min(maxLeft[i], maxRight[i]) - height[i];
            if (count > 0) sum += count;
        }
        return sum;
    }
}

84. 柱状图中最大的矩形

思路：单调栈，顺序是递减，每一次出栈都将计算当前出栈高度与左右比自己更高的高度所形成矩形面积。通过本题，我们可以得出进栈元素是更新结果的一个边界；由于单调栈的单调特性，因此栈顶的下一个位置的元素是另一个边界，即结果可以通过这三者完成计算。此外采用栈顶元素的下一个位置的元素直接参与计算，那么自然在当前元素出栈后，将会以下一个元素作为栈顶来开展下一此结果更新，那么所谓的高度差的概念，其实是去栈内每一次计算结果时，需要将当前位置的高度与左右两侧边界的高度进行三者的筛选，在接雨水题中，需要用左右两侧的最小值减去当前位置高度得到当前位置的雨水量。而在矩形中，高度差体现在每次更新面积时，height[mid]就是当前高度范围内的最小值，考虑了与(left,right)之间高度的高度比较，即高度差。

class Solution {
    int largestRectangleArea(int[] heights) {
        ArrayDeque<Integer> st = new ArrayDeque<>();
        
        // 数组扩容，在头和尾各加入一个元素，为了有效的应对heights全员递增或全员递减的情况
        int [] newHeights = new int[heights.length + 2];
        newHeights[0] = 0;
        newHeights[newHeights.length - 1] = 0;
        for (int index = 0; index < heights.length; index++){
            newHeights[index + 1] = heights[index];
        }

        // 原来的数组指向扩容完成的数组
        heights = newHeights;
        
        st.push(0);
        int result = 0;
        // 第一个元素已经入栈，从下标1开始
        for (int i = 1; i < heights.length; i++) {
            // 栈内排序是递减的，遇到更大的元素直接进栈
            if (heights[i] > heights[st.peek()]) {
                st.push(i);
            } else if (heights[i] == heights[st.peek()]) {
                st.pop(); // 加不加都行，因为以相等高度进行求解时，左侧相等的高度不会存在高度差的问题，但是还是出栈比较好，这样减少后续计算量
                st.push(i);
            } else {
                // 注意，从左开始向右进行遍历，则持续出栈的过程中每一次出栈都可以更新结果
                while (heights[i] < heights[st.peek()]) { 
                    // 获取当前高度
                    int mid = st.peek();
                    st.pop();
                    // 获取左侧高度
                    int left = st.peek();
                    // 获取右侧高度
                    int right = i;
                    // 计算长，这一步非常的关键，这里剔除了高度更小的left和right加入计算，而是去已经left与right之间已经出栈的高的高度加入计算
                    // 如果mid是最高的，那么w等于1；如果mid不是最高的，那么(left,right)之间的元素都比height[mid]来的更大
                    int w = right - left - 1;
                    // 当前出栈元素是三个位置内高度最高的，以mid为基准进行面积计算
                    int h = heights[mid];
                    result = Math.max(result, w * h);
                }
                st.push(i);
            }
        }
        return result;
    }
}