//来自https://blog.csdn.net/qq1169091731/article/details/52006440
poj 2559 最大矩形面积
【题意】给定从左到右多个矩形,已知这此矩形的宽度都为1,长度不完全相等。
这些矩形相连排成一排,求在这些矩形包括的范围内能得到的面积最大的矩形,
打印出该面积。所求矩形可以横跨多个矩形,但不能超出原有矩形所确定的范围。
【分析】建立一个单调递增栈,所有元素各进栈和出栈一次即可。
设栈内的元素为一个二元组(x, y),x表示矩形的高度,y表示矩形的宽度。
每个元素出栈的时候更新最大的矩形面积。
要想找到里面的最大的面积,一定会有这么一种情况,
得出的矩形的高度一定为“所包含的某一个高度”。
所以我们可以对某一个柱子的高度为标准,尽量的向两头扩展,
这样就可以找出以它高度为标准的,并包含它本身的最大矩形。
然后对每一个柱子都做类似的工作,最后挑出里面最大的矩形。
单从上述所说,一定会有重复的工作,如何剔除重复工作呢?
而且什么叫做尽量向两头扩展呢?
如:2 1 4
第一个:2,以2为高度为准,向左右两头扩展,它只能向右扩展,
因为1比2低了,就不可能扩展到1了。宽度只有1。
第二个:1,以1为高度为准,向左右两头扩展,向左,
因为2比1高可以扩展过去;向右,因为4也高于1所以扩展到4,这样以1为高度的矩形宽为3了;
第三个:4,以4为高度为准,向左右两头扩展,
向左,因为4比1、2都高,显然不可以扩展过去,这样以4为高度的矩形宽为1了。
所以要将其扩展过去,必须高度不低于当前扩展点的高度。
所以如果我们从第一个开始计算到第n个,计算到 i 时,
如果我们可以快速的找出左边第一个(这里第一的意思是离i最近)比 i 的高度小的,
就可以完成了向左扩展的工作。而向右扩展,我们本来就是一直向右走,所以直接扩展。
这时候就轮到:单调栈了。(一直保持单调递增的栈。)
思考刚才的例子:
2进栈,左边没有比它小的元素,所以记录其最左扩展位置为1。
1准备进栈,因为其进栈就破坏了单调栈的性质(2>1),这时2要出栈,
因为1<2也说明了2不可能向右扩展,出栈,计算以2为准的矩形 2*1,然后1才进栈。
1进栈前,发现其前一个元素,既是当前的栈顶2,比1高,
而且2的左扩展从位置1开始,所以1也有理由从2的左起始位置开始(注意:2比1高),
所以2出栈后,1进栈,其左扩展应为2的左扩展位置1;
4准备进栈,因为4>1直接进栈,其左扩展位置只能为3了。
最后要清空栈:4退栈,以为是最右的了,这此时右扩展只能为3了。
左右扩展都为3,即是其本身,矩形为4*1;记录其位置以备后需;
1退栈,最右扩展只能是上一个退栈的元素位置,因为其高度比1高(单调栈的性质),
所以利用刚才记录的位置,1的左右扩展就为1,3了,矩形1*3;
Q:如何压栈并更新呢?
① 如果当前元素比栈顶元素大或者栈为空,则直接压栈(x,1)。
② 如果当前元素小于等于栈顶元素,退栈直到当前元素大于栈顶元素或者栈为空,压栈。
③在退栈的过程中要进行最大面积和累积宽度的更新。
//来自http://www.cnblogs.com/lichen782/p/leetcode_Largest_Rectangle_in_Histogram.html
例子就用题目中的[2,1,5,6,2,3]吧。
首先,如果栈是空的,那么索引i入栈。那么第一个i=0就进去吧。
注意栈内保存的是索引,不是高度。然后i++。
然后继续,当i=1的时候,发现h[i]小于了栈内的元素,于是出栈。
(由此可以想到,哦,看来stack里面只存放单调递增的索引)
这时候stack为空,所以面积的计算是h[t] * i.t是刚刚弹出的stack顶元素。也就是蓝色部分的面积。
继续。这时候stack为空了,继续入栈。注意到只要是连续递增的序列,
我们都要keep pushing,直到我们遇到了i=4,h[i]=2小于了栈顶的元素。
这时候开始计算矩形面积。首先弹出栈顶元素,t=3。即下图绿色部分。
接下来注意到栈顶的(索引指向的)元素还是大于当前i指向的元素,
于是出栈,并继续计算面积,桃红色部分。
最后,栈顶的(索引指向的)元素大于了当前i指向的元素,循环继续,
入栈并推动i前进。直到我们再次遇到下降的元素,也就是我们最后人为添加的dummy元素0.
同理,我们计算栈内的面积。由于当前i是最小元素,
所以所有的栈内元素都要被弹出并参与面积计算。
注意我们在计算面积的时候已经更新过了maxArea。
总结下,我们可以看到,stack中总是保持递增的元素的索引,
然后当遇到较小的元素后,依次出栈并计算栈中bar能围成的面积,直到栈中元素小于当前元素。
可是为什么这个方法是正确的呢?
可以这样理解这个算法,看下图。
例如我们遇到最后遇到一个递减的bar(红色)。
高度位于红线上方的(也就是算法中栈里面大于最右bar的)元素,
他们是不可能和最右边的较小高度bar围成一个比大于在弹栈过程中的矩形面积了(黄色面积),
因为红色的bar对他们来说是一个短板,和红色bar能围成的最大面积。
也就是红色的高度乘以这些“上流社会”所跨越的索引范围。
但是“上流社会”的高度个个都比红色bar大,
他们完全只计算彼此之间围成的面积就远远大于和红色bar围成的任意面积了。
所以红色bar是不可能参与“上流社会”的bar的围城的(好悲哀)。
但是屌丝也不用泄气哦。因为虽然长度不占优势,但是团结的力量是无穷的。
它还可以参与“比较远的”比它还要屌丝的bar的围城。
他们的面积是有可能超过上流社会的面积的,因为距离啊!所以弹栈到比红色bar小就停止了。
另外一个细节需要注意的是,弹栈过程中面积的计算。
h[t] * (stack.isEmpty() ? i : i - stack.peek() - 1)
h[t]是刚刚弹出的栈顶端元素。此时的面积计算是h[t]和前面的“上流社会”能围成的最大面积。
注意,栈内索引指向的元素都是比h[t]小的,如果h[t]是目前最小的,那么栈内就是空。
而在目前栈顶元素和h[t]之间(不包括h[t]和栈顶元素),都是大于他们两者的。
那h[t]无疑就是Stack.Peek和t之间那些上流社会的短板啦,而它们的跨越就是i - Stack.Peek - 1。
所以说,这个弹栈的过程也是维持程序不变量的方法啊:
栈内元素一定是要比当前i指向的元素小的。
#include <iostream>
#include <stack>
#include <cstdio>
using namespace std; //直接用栈
struct Node{
long long val;
long long len;
};
stack<Node> s;
int main(){
long long temp,Max,n,i,m;
Node q;
while(scanf("%I64d",&n)!=EOF){
if(n==0) break;
Max=0;
for(i=0;i<n;i++){
scanf("%I64d",&q.val);
q.len=1;
temp=0;
if(s.empty()) s.push(q);
else if(q.val<=(s.top()).val){
while(!s.empty()&&q.val<=(s.top().val)){
(s.top()).len+=temp;
m=(s.top()).val*(s.top()).len;
if(m>Max) Max=m;
temp=(s.top()).len;
s.pop();
}
q.len+=temp;
s.push(q);
}
else s.push(q);
}
temp=0;
while(!s.empty()){
(s.top()).len+=temp;
m=(s.top()).val*(s.top()).len;
if(m>Max) Max=m;
temp=(s.top()).len;
s.pop();
}
cout<<Max<<endl;
}
}
#include <iostream>
#include <cstdio>
using namespace std; //数组模拟栈
#define maxn 100005
pair<long long,long long> p[maxn];
int main(){
long long n,num,k,i,Max,m,prev;
while(scanf("%I64d",&n)!=EOF){
if(n==0) break;
Max=0;
scanf("%I64d",&p[0].first); //first表示高度,second表示宽度
p[0].second=1;
k=0;
for(i=1;i<=n;i++){
if(i<n) scanf("%I64d",&num);
else num=-1;
prev=0;
while(k>=0&&num<=p[k].first){
p[k].second+=prev;
m=p[k].first*p[k].second;
if(m>Max) {Max=m;}
prev=p[k].second;
k--;
}
if(num!=-1){
p[++k].second=prev+1;
p[k].first=num;
}
}
printf("%I64d\n",Max);
}
return 0;
}