栈学习-----柱形图的最大矩形

class Solution {

public:

    int largestRectangleArea(vector<int> & heights)

    {

        int length = 0;

        stack<int> s;

        s.push(-1);

        for(int i = 0;i < heights.size();i++)

        {

            if(s.top() == -1)                          //栈为空，将数组下标压入栈中

                s.push(i);

            else if(heights[s.top()] < heights[i])     //当栈顶下标所对应的元素比当前下标元素小的时候，将当前下标压入栈中

                s.push(i);

            else if(heights[s.top()] == heights[i])    //当栈顶下标所对应的元素等于当前下标元素

            {

                s.pop();                               //将当前栈顶下标出栈

                s.push(i);                             //将目前下标压入栈中

            }

            else

            {

                while(heights[s.top()] > heights[i])   //当前栈顶所对应的元素大于当前下标元素

                {

                    int height = heights[s.top()];     //计算此时的矩形高度

                    s.pop();                           //栈顶出栈

                    int width = i - s.top() - 1;       //计算此时的矩形宽度

                    int area = height * width;

                    if(length < area)

                    {

                        length = area;

                    }

                    if(s.top() == -1)

                        break;

                }

                s.push(i);    

            }

        }

        int temp = 0;

        if(s.top() != -1)

            temp = s.top() + 1;

        while(s.top() != -1)

        {

            int height = heights[s.top()];

            s.pop();

            int width = temp - s.top() - 1;

            int area = height * width;

            if(length < area)

            {

                length = area;

            }

        }

        return length;

    }

};

算法思路：这次自己没有想出算法来，一开始想着用昨天做雨水的暴力求解，然后超时了。。想了挺多实现的时候发现都有纰漏，后面看了看评论区都在提单调栈，然后看了单调栈算法的思路，自己实现了它。收获还是挺大的。

 

以下是超时的暴力求解方法：

class Solution {

public:

    int largestRectangleArea(vector<int> & heights)

    {

        int length = 0;

        for(int i = 0;i < heights.size();i++)

        {

            int temp = heights[i];                    //temp存储当前最低高度

            for(int j = i;j < heights.size();j++)

            {

                if(heights[j] < temp)                 //遍历到比temp还要低的元素

                {                

                    int sum = temp * (j - i);         //判断是否为大于之前所求的面积

                    if(sum > length)

                        length = sum;

                    temp = heights[j];                //将temp元素的值更新

                }

                if(j == heights.size() - 1)

                {

                    int sum = temp * (j - i + 1);

                    if(sum > length)

                        length = sum;

                }

            }

        }

        return length;

    }

};