最大的矩形问题（201312-3）

试题编号： 201312-3
试题名称： 最大的矩形
时间限制： 1.0s
内存限制： 256.0MB
问题描述：
问题描述
　　在横轴上放了n个相邻的矩形，每个矩形的宽度是1，而第i（1 ≤ i ≤ n）个矩形的高度是hi。这n个矩形构成了一个直方图。例如，下图中六个矩形的高度就分别是3, 1, 6, 5, 2, 3。

请找出能放在给定直方图里面积最大的矩形，它的边要与坐标轴平行。对于上面给出的例子，最大矩形如下图所示的阴影部分，面积是10。

输入格式
　　第一行包含一个整数n，即矩形的数量(1 ≤ n ≤ 1000)。
　　第二行包含n 个整数h1, h2, … , hn，相邻的数之间由空格分隔。(1 ≤ hi ≤ 10000)。hi是第i个矩形的高度。
输出格式
　　输出一行，包含一个整数，即给定直方图内的最大矩形的面积。
样例输入
6
3 1 6 5 2 3
样例输出
10

蛮力算法

  我们最先想到的办法就是枚举所有的子区间，找出每个子区间中最小的那个数，再乘上子区间含有元素的个数，也就是所谓的底，最后再比较所有子区间中面积最大的那个就好了。
  维护两个指针指向最左端，并通过两个指针的移动来枚举所有的子区间，下图只标出了部分子区间：

最终的代码如下：

int getAnswer(int n , int* h){ //蛮力解法：复杂夫o(n^3)
	int ans = 0; 
	for(int a = 1 ; a <= n ; a++){
		for(int b = a ; b <= n ; b++){
			int minH = 50000;
			for(int c = a; c <= b ; c++)
				minH = min(minH,h[c]);
			ans = max(ans , (b-a+1)*minH);
		}
		
	}
	return ans;
}

蛮力算法的优化

  我们要找到每一个子区间的最小值，假设 minH 是[1,j]区间的最小值，那么[1,j+1]区间的最小值一定是minH 与j+1 位置的值之中较小的那个，所以我们完全不用另设一个c变量再循环一趟，仅需在变量b遍历的时候就可以开始计算ans了，具体代码如下：

int getAnswer(int n , int* h){ //蛮力解法优化：复杂夫o(n^2)
	int ans = 0; 
	for(int a = 1 ; a <= n ; a++){
		int minH = 50000;
		for(int b = a ; b <= n ; b++){
			minH = min(minH,h[b]);
			ans = max(ans , (b-a+1)*minH);	
		}

单调栈法

  由于该题规模很小，实际上优化过后的蛮力算法已经可以拿满分了，但是如果数据规模再大一点，上面的蛮力算法就无能为力了。
  有没有更好的算法呢？答案是肯定的，我们仅需要维护一个栈数据结构，就可以大幅度简化蛮力算法的步骤。

  如上图，地下的黑字是方型的位置，上面的红字代表每个直方的高度，两端的虚框是我们假象的哨兵元素，高度为0，意思是直方图中的所有直方都比这个哨兵高。
  我们再来审视一下蛮力算法中寻找最大面积的方法，找到所有的子区间，再找到子区间中的最小项，再乘以区间直方个数 找出所有子区间中最大的。
  我们更进一步思考，如何求子区间[1,1]中的面积呢？观察发现位置1两边有两个“卡座”，都低于他的高度（哨兵高度为0，上文已经提及）。
  借助一些贪心的思路，找到最大的面积肯定要从最高的直方开始找，我们短视地认为，每找到一个“下坡”（位置1到位置2），我们就直观地认为位置1是最高的直方，位置2是他的右卡座，哨兵是他的左卡座，我们记录下这个假象的最高直方的高度，然后再乘以（右卡座位置-左卡座位置 - 1），就是该区间的最大面积； 我们维护一个栈stack ，如果遇到”上坡”，将该位置压入栈，如果遇到下坡，进行计算最大面积。
  我们来模拟一遍：

  初始状态，先将哨兵元素压如栈，再对比位置1 ，比栈顶位置的直方高，压入栈。

  再往后，位置2的直方高度没有栈顶位置直方高，所以记录下栈顶位置的直方高度，进行一个pop操作后，再乘以（右卡座（位置2） - 左卡座（当前栈顶） -1）。
  接下来是位置2和栈顶比较，2 > 0 , 位置2入栈，再比较，位置3入栈，再比较，位置4比目前栈顶的位置小，记录栈顶，再pop出来，再以当前栈顶作为左卡座和右卡座，算出面积，再继续比，发现栈顶位置依旧更大，就重复上述操作，直至完成一轮遍历。
  最后末尾处依旧要假象一个哨兵，用作计算最后这个直方图本身的面积。
最终代码如下：

int getAnswer(int n , int* height){ //单调栈算法
	int ans = 0;
	stack<int> myStack ;
	myStack.push(0); //哨兵
	for(int i = 1 ; i <= n+1 ;){
		if(height[myStack.top()] > height[i]){
			int nowHeight = height[myStack.top()];
			myStack.pop();
			ans = max(ans,(i-myStack.top()-1)*nowHeight);
		}
		else
			myStack.push(i++);
	}
	return ans;
}

完整代码及测试

#include <iostream>
#include <stack>
#include <algorithm>
using namespace std;


// int getAnswer(int n , int* h){ //蛮力解法：复杂夫o(n^3)
// 	int ans = 0; 
// 	for(int a = 1 ; a <= n ; a++){
// 		for(int b = a ; b <= n ; b++){
// 			int minH = 50000;
// 			for(int c = a; c <= b ; c++)
// 				minH = min(minH,h[c]);
// 			ans = max(ans , (b-a+1)*minH);
// 		}
		
// 	}
// 	return ans;
// }


// int getAnswer(int n , int* h){ //蛮力解法优化：复杂夫o(n^2)
// 	int ans = 0; 
// 	for(int a = 1 ; a <= n ; a++){
// 		int minH = 50000;
// 		for(int b = a ; b <= n ; b++){
// 			minH = min(minH,h[b]);
// 			ans = max(ans , (b-a+1)*minH);	
// 		}		
// 	}
// 	return ans;
// }



int getAnswer(int n , int* height){ //单调栈算法
	int ans = 0;
	stack<int> myStack ;
	myStack.push(0); //哨兵
	for(int i = 1 ; i <= n+1 ;){
		if(height[myStack.top()] > height[i]){
			int nowHeight = height[myStack.top()];
			myStack.pop();
			ans = max(ans,(i-myStack.top()-1)*nowHeight);
		}
		else
			myStack.push(i++);
	}
	return ans;
}


int main()
{
	int n;
	cin>>n ;
	int* height = new int[n+2]();

	for(int i = 1; i <= n ; ++i)
		cin>>height[i];
	cout<<getAnswer(n,height)<<endl;
	delete[] height; 
	return 0;
}