代码随想录训练营第六十四天打卡|84.柱状图中最大的矩形

84.柱状图中最大的矩形

1.暴力法，时间开销只击败了5%，但毕竟是自己写的。朴素思想，以每一个柱子的高作为最终勾勒出的矩形的高求取面积，最后取最大值。求取面积的过程中，要找到以该根柱子作高，勾勒出矩形的宽。所以要找到左右第一个比该柱子矮的柱子的下标，这就是leftMinIndex，rightMinIndex两个数组的作用。如果左边没有柱子更矮了，那下标就为-1，右边没有柱子更矮了，下标就为n。

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        int n = heights.size();
        vector<int> leftMinIndex(n, -1);
        for (int i = 1; i < n; i++) {
            if (heights[i] == heights[i - 1]) {
                leftMinIndex[i] = leftMinIndex[i - 1];
                continue;
            }
            int j;
            for (j = i - 1; j >= 0; j--) {
                if (heights[j] < heights[i]) {
                    break;
                }
            }
            leftMinIndex[i] = j;
        }
        vector<int> rightMinIndex(n, n);
        for (int i = n - 2; i >= 0; i--) {
            if (heights[i] == heights[i + 1]) {
                rightMinIndex[i] = rightMinIndex[i + 1];
                continue;
            }
            int j;
            for (j = i + 1; j < n; j++) {
                if (heights[j] < heights[i]) {
                    break;
                }
            }
            rightMinIndex[i] = j;
        }
        int result = 0;
        for (int i = 0; i < n; i++) {
            int s = heights[i] * (rightMinIndex[i] - leftMinIndex[i] - 1);
            result = max(result, s);
        }
        return result;
    }
};

2.双指针法。双指针法乍一看和暴力法一模一样，其实区别在于leftMinIndex，rightMinIndex两个数组的建立过程中。暴力法中是一步一步移动的，而双指针法是利用之前已经得到过的信息。为什么可以这样，因为leftMinIndex，rightMinIndex两个数组的含义是左边（右边）第一个小于该柱子高度的柱子的下标。以leftMinIndex数组为例，1,3,4,5,7,6,5。遍历到6这个柱子时，左边7比它高，那我们就直接跳到第一个比7矮的柱子5这就是目标柱子，记录下标就行。遍历到最后一个柱子5时，左边柱子6比它高，那我们就直接跳到第一个比6矮的柱子5,5>=5，所以我们继续跳到4找到目标柱子返回下标。其中7就被我们跳过了，在实际情况中，被跳过的柱子数可能更多，提高了效率。

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        int n = heights.size();
        vector<int> leftMinIndex(n, -1);
        for (int i = 1; i < n; i++) {
            int j = i - 1;
            while (j >= 0 && heights[j] >= heights[i]) {
                j = leftMinIndex[j];
            }
            leftMinIndex[i] = j;
        }
        vector<int> rightMinIndex(n, n);
        for (int i = n - 2; i >= 0; i--) {
            int j = i + 1;
            while (j < n && heights[j] >= heights[i]) {
                j = rightMinIndex[j];
            }
            rightMinIndex[i] = j;
        }
        int result = 0;
        for (int i = 0; i < n; i++) {
            int s = heights[i] * (rightMinIndex[i] - leftMinIndex[i] - 1);
            result = max(result, s);
        }
        return result;
    }
};

3.单调栈，简洁写法。注意数组开头末尾分别加0是为了防止递减数组和递增数组的极端情况，详情见随想录。单调栈的核心在于while循环，虽然之前的元素出栈了，但由于保存的是下标，达到了一种“音容宛在”的效果。

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        stack<int> st;
        heights.insert(heights.begin(), 0);
        heights.push_back(0);
        int result = 0;
        for (int i = 0; i < heights.size(); i++) {
            while (!st.empty() && heights[i] < heights[st.top()]) {
                int h = heights[st.top()];
                st.pop();
                int w = i - st.top() - 1;
                result = max(result, h * w);
            }
            st.push(i);
        }
        return result;
    }
};

4.单调栈，详细注释版。

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        int result = 0;
        stack<int> st;
        heights.insert(heights.begin(), 0); // 数组头部加入元素0
        heights.push_back(0);               // 数组尾部加入元素0
        st.push(0);

        // 第一个元素已经入栈，从下标1开始
        for (int i = 1; i < heights.size(); i++) {
            if (heights[i] > heights[st.top()]) { // 情况一
                st.push(i);
            } else if (heights[i] == heights[st.top()]) { // 情况二
                st.pop(); // 这个可以加，可以不加，效果一样，思路不同
                st.push(i);
            } else { // 情况三
                while (!st.empty() &&
                       heights[i] < heights[st.top()]) { // 注意是while
                    int mid = st.top();
                    st.pop();
                    if (!st.empty()) {
                        int left = st.top();
                        int right = i;
                        int w = right - left - 1;
                        int h = heights[mid];
                        result = max(result, w * h);
                    }
                }
                st.push(i);
            }
        }
        return result;
    }
};

今日总结：结束？