POJ 2082 Terrible Sets

Terrible Sets

Time Limit: 1000MS		Memory Limit: 30000K
Total Submissions: 2747		Accepted: 1389

Description

Let N be the set of all natural numbers {0 , 1 , 2 , . . . }, and R be the set of all real numbers. wi, hi for i = 1 . . . n are some elements in N, and w0 = 0. 
Define set B = {< x, y > | x, y ∈ R and there exists an index i > 0 such that 0 <= y <= hi ,∑ _0<=j<=i-1wj <= x <= ∑ _0<=j<=iwj} 
Again, define set S = {A| A = WH for some W , H ∈ R ⁺ and there exists x0, y0 in N such that the set T = { < x , y > | x, y ∈ R and x0 <= x <= x0 +W and y0 <= y <= y0 + H} is contained in set B}. 
Your mission now. What is Max(S)? 
Wow, it looks like a terrible problem. Problems that appear to be terrible are sometimes actually easy. 
But for this one, believe me, it's difficult.

Input

The input consists of several test cases. For each case, n is given in a single line, and then followed by n lines, each containing wi and hi separated by a single space. The last line of the input is an single integer -1, indicating the end of input. You may assume that 1 <= n <= 50000 and w ₁h ₁+w ₂h ₂+...+w _nh _n < 10 ⁹.

Output

Simply output Max(S) in a single line for each case.

Sample Input

3
1 2
3 4
1 2
3
3 4
1 2
3 4
-1

Sample Output

12
14
题目大意：给出一系列矩形的宽度和高度，矩形沿着x轴对齐，求这些矩形组成的连续矩形区域的最大面积。
解题方法：这是一道非常好的题，用栈保存矩形，如果高度递增则不断入栈，如果遇到当前输入的比栈顶高度小，则从栈顶开始不断出栈并且计算最大面积，直到栈顶高度小于当前输入高度则停止出栈，并把开始出栈矩形的宽度累加得到totalw,把totalw和当前输入的矩形宽度相加得到当前输入矩形的宽度，并入栈，这样栈中保存的永远都是高度递增的矩形，最后输入完了之后如果栈不为空，则依次出栈并计算最大面积。

#include <stdio.h>
#include <iostream>
#include <string.h>
#include <stack>
using namespace std;

typedef struct
{
    int w;
    int h;
}Node;

int main()
{
    stack<Node> Stack;
    int totalw, ans, w, h, n;
    while(scanf("%d", &n) != EOF && n != -1)
    {
        ans = 0;
        for (int i = 0; i < n; i++)
        {
            scanf("%d%d", &w, &h);
            if (Stack.empty())//如果栈为空，则入栈
            {
                Node temp;
                temp.w = w;
                temp.h = h;
                Stack.push(temp);
            }
            else
            {
                totalw = 0;
                if (h >= Stack.top().h)//如果当前矩形高度大于栈顶矩形高度，入栈
                {
                    Node temp;
                    temp.w = w;
                    temp.h = h;
                    Stack.push(temp);
                }
                else
                {
                    //如果当前输入矩形高度小于栈顶矩形高度，出栈并计算最大面积
                    while(!Stack.empty() && Stack.top().h > h)
                    {
                        //宽度从栈顶开始依次累加
                        totalw += Stack.top().w;
                        if (ans < totalw * Stack.top().h)
                        {
                            //得到最大面积
                            ans = totalw * Stack.top().h;
                        }
                        Stack.pop();
                    }
                    Node temp;
                    //出栈完毕之后，栈为空或者栈顶矩形高度小于当前输入高度，
                    //以保证栈中的矩形高度递增
                    temp.w = w + totalw;//加上开始出栈的所有矩形宽度之和，即为当前输入矩形的宽度
                    temp.h = h;
                    Stack.push(temp);
                }
            }
        }
        totalw = 0;
        //如果栈不为空，则依次出栈并计算最大面积
        while(!Stack.empty())
        {
            totalw += Stack.top().w;
            if (ans < totalw * Stack.top().h)
            {
                ans = totalw * Stack.top().h;
            }
            Stack.pop();
        }
        printf("%d\n", ans);
    }
    return 0; 
}