Leetcode 84 柱状图中最大的矩形

更加丰富内容可查看我的个人博客：xukang’s blog

做题感受：

弄清楚暴力算法往往是得到优化算法的第一步

对于这道题，不仅仅满足于掌握单调栈的优化算法，

更重要的是，先把暴力算法弄懂，弄透，想想暴力算法的不足之处。

想想这些不足该怎么优化办法，感受学习人家的优化方法。

这样才能够真正弄懂优化算法优化了什么，才能感受到优化算法的妙处，

与这道题相似的接雨水，其优化算法相对比较有跳跃性！不像这道题循序渐进，容易理解优化算法。

我们需要在柱状图中找出最大的矩形，因此我们可以考虑枚举矩形的宽和高，其中「宽」表示矩形贴着柱状图底边的宽度，「高」表示矩形在柱状图上的高度。这道题枚举「高」很容易想出！

方法1、暴力枚举 ”高“

从左往右遍历「高」，然后找每个高度的 左边第一个小于它的位置，右边第一个小于它的位置，从而得到对应的「底」

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        int res = 0;

        for (int i = 0; i < heights.size(); i++) {
            int height = heights[i];
            int j = i - 1;
            int k = i + 1;

            while (j >= 0 && heights[j] >= heights[i]) j--;
            while (k < heights.size() && heights[k] >= heights[i]) k++;

            res = max(res,  height * (k - j - 1));
        }
        return res;
    }
};

方法2、枚举 ”高“的优化，使用栈

把暴力方法弄清楚之后，很容易发现这几个问题！

1. 我们从左往右遍历「高」，然后找每个高度的 左边第一个小于它的位置，右边第一个小于它的位置。发现有重复搜索，可以利用一个单调栈，来存储已经查找过的数据。
2. 对于某个「高」 heights[i] , 如果没有找到小于它的。也就是说，左右两边都大于它。
   最后搜索的下标会来到 -1 和 size ( = heights.size( ) )。 因此其左边界 为-1，右边界 size。同样，第一个元素的左边界为-1，最后一个元素的右边界为size。
3. 利用单调栈存储「高」。
   • 当前heights[i] >= heights[stk.top()],就将其下标压入栈中！
   • 当前heights[i] < heights[stk.top()], 说明 「高」 heights[stk.top()]的右边第一个小于它的位置就是 i 。又由于是单调递增栈，其栈中的前面一个下标，可以当做其左边第一个小于它的位置。但是如果有重复元素的话，严格来说不应该是，但是会发现这个结果是肯定会被下面的值覆盖。对于栈首元素，其左边界就是-1。当遍历完整个数组，单调递增栈肯定还有高度没有求！这些元素的右边界都是size。

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        int res = 0;
        stack<int> stk;
        int size = heights.size();
        for (int i = 0; i < size; i++) {
            while (!stk.empty() && heights[i] < heights[stk.top()]) {
                int tmp = stk.top();
                stk.pop();
                res = max(res, heights[tmp] * (stk.empty() ? i : i - stk.top() - 1));
            }
            stk.push(i);
        }

        while (!stk.empty()) {
            int tmp = stk.top();
            stk.pop();
            res = max(res, heights[tmp] * (stk.empty() ? size : size - stk.top() - 1));         
        }    
        return res;
    }
};

对于栈首元素，其左边界就是-1，我们可以将其先压入栈中，这样就可以统一了。

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        int res = 0;
        std::stack<int> stk;
        stk.push(-1);  //左边界-1，可以提前加进去，i= i -（-1）+ 1；
        for (int i = 0; i < heights.size(); i++) {
            while (stk.size() > 1 && heights[i] < heights[stk.top()]) {
                int tmp = stk.top();
                stk.pop(); //由于stk添加了一个-1，这里的弹出操作，永远不会将stk变为空
                res = max(res , heights[tmp] * (i - stk.top() - 1));
            }
            stk.push(i);
        }

        while (stk.size() > 1) {
            int tmp = stk.top();
            stk.pop();
          	//(int)heights.size() 无符号整数计算要小心！
            res = max(res , heights[tmp] * ((int)heights.size() - stk.top() - 1));
        }
        return res;
    }
};

方法3、枚举 ”高“的再优化，使用 栈 + 哨兵

我们可以添加一个哨兵，将代码更加优化！

class Solution {
public:  
    int largestRectangleArea(vector<int>& heights) {
        int res = 0;
        std::stack<int> stk;
        heights.push_back(0); //添加一个哨兵！可以将最后的循环合并！
    
        for (int i = 0; i < heights.size(); i++) {
            while (!stk.empty() && heights[i] < heights[stk.top()]) {
                int tmp = stk.top();
                stk.pop();
                res = max(res , heights[tmp] * (stk.empty() ? i : (i - stk.top() - 1)));
            }
            stk.push(i);
        }
        return res;
    }
};

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        int res = 0;
        std::stack<int> stk;
        stk.push(-1);
        heights.push_back(0);  //添加一个哨兵！可以将最后的循环合并！
        for (int i = 0; i < heights.size(); i++) {
            while (stk.size() > 1 && heights[i] < heights[stk.top()]) {
                int tmp = stk.top();
                stk.pop();
                res = max(res , heights[tmp] * (i - stk.top() - 1));
            }
            stk.push(i);
        }
        return res;
    }
};

其实除了将左边界 -1加进stack + 一个哨兵，还可以直接使用两个哨兵

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        int res = 0;
        stack<int> stk;
        heights.push_back(0);
        heights.insert(heights.begin(), 0);

        for (int i = 0; i < heights.size(); i++) {
            while (!stk.empty() && heights[i] < heights[stk.top()]) {
                int tmp = stk.top();
                stk.pop();
                res = max(res, heights[tmp] * (i - stk.top() - 1));
            }
            stk.push(i);
        }

        return res;
    }
};

总结下来，右边界的优化用哨兵！左边界可以用哨兵，也可以直接往栈中添加左边界！