hdu 1506 单调栈问题

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1506

题目的意思其实就是要找到一个尽可能大的矩形来完全覆盖这个矩形下的所有柱子，只能覆盖柱子，不能留空。

我们求得的面积其实就是Max{s=(right[i] - left[i] + 1)*height[i];(i>=1&&i<=n)}

每一个柱子都要尽可能向左向右延伸，使得获得最大的面积。

此时我就要用到单调栈

单调栈就是栈内元素单调递增或者单调递减的栈，单调栈只能在栈顶操作。

http://blog.csdn.net/liujian20150808/article/details/50752861

这里我们还是做一个总结

单调栈的维护是 O(n) 级的时间复杂度，因为所有元素只会进入栈一次，并且出栈后再也不会进栈了。

单调栈的性质：

1.单调栈里的元素具有单调性

2.元素加入栈前，会在栈顶端把破坏栈单调性的元素都删除

3.使用单调栈可以找到元素向左遍历第一个比他小的元素，也可以找到元素向左遍历第一个比他大的元素。

基于此题，我们可以知道，先每一次从左到右放入柱子（保持递增单调栈），也就说一旦有一个柱子和栈顶元素一比发现比它大，那么这个柱子首先要记录它的left值为自己的本身的下标，如果发现这个柱子比栈顶的小，我们依次将栈顶元素出栈，直至又能组成递增的序列，此时这个柱子的left值就为现在栈顶的left值。

后面我们从右向左放入柱子（保持的依旧是递增的单调栈）。获得right值。

代码如下

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<stack>
 #define LL long long
 using namespace std;
 const int MAXN = ;
 struct node
 {
     LL height;
     int left;
     int right;
     int index;
 };
 node nd[MAXN];
 int n;
 stack <node> st;//定义一个单调栈
 void clr()
 {
     while(!st.empty())
         st.pop();
 }
 LL work()
 {
     clr();
     for(int i = ;i<=n;i++)
     {
         if(st.empty())
         {
             nd[i].left = i;
             st.push(nd[i]);
         }
         else
         {
             node td = st.top();
             if(td.height<nd[i].height)
             {
                 nd[i].left = i;
                 st.push(nd[i]);
             }
             else
             {
                 bool flag=false;
                 int c;
                 while(!st.empty())
                 {
                     if((st.top()).height>=nd[i].height)
                     {
                         c = (st.top()).left;
                         st.pop();
                     }
                     else
                     {
                         nd[i].left = c;
                         flag =true;
                         st.push(nd[i]);
                         break;
                     }
                 }
                 if(flag == false)
                 {
                     nd[i].left = c;
                     st.push(nd[i]);
                 }
             }
         }
     }
     clr();
     for(int i = n;i>=;i--)
     {
         if(st.empty())
         {
             nd[i].right = i;
             st.push(nd[i]);
         }
         else
         {
             node td = st.top();
             if(td.height<nd[i].height)
             {
                 nd[i].right = i;
                 st.push(nd[i]);
             }
             else
             {
                 bool flag=false;
                 int c;
                 while(!st.empty())
                 {
                     if((st.top()).height>=nd[i].height)
                     {
                         c = (st.top()).right;
                         st.pop();
                     }
                     else
                     {
                         nd[i].right = c;
                         st.push(nd[i]);
                         flag = true;
                         break;
                     }
                 }
                 if(flag == false)
                 {
                     nd[i].right = c;
                     st.push(nd[i]);
                 }
             }
         }
     }
     LL maxs = ;
     LL s;
     for(int i = ;i<=n;i++)
     {
         s = (nd[i].right - nd[i].left + )*nd[i].height;
         if(maxs<s)
             maxs = s;
     }
     return maxs;
 }
 int main()
 {
     while(~scanf("%d",&n))
     {
         if(n==)
             break;
         for(int i = ;i<=n;i++)
         {
             nd[i].index = i;
             scanf("%I64d",&nd[i].height);
         }
         cout<<work()<<endl;
     }
     return ;
 }