hdu 1506(好题+DP或者RMQ)

Largest Rectangle in a Histogram

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 15396    Accepted Submission(s): 4470

Problem Description

A
histogram is a polygon composed of a sequence of rectangles aligned at a
common base line. The rectangles have equal widths but may have
different heights. For example, the figure on the left shows the
histogram that consists of rectangles with the heights 2, 1, 4, 5, 1, 3,
3, measured in units where 1 is the width of the rectangles:

Usually,
histograms are used to represent discrete distributions, e.g., the
frequencies of characters in texts. Note that the order of the
rectangles, i.e., their heights, is important. Calculate the area of the
largest rectangle in a histogram that is aligned at the common base
line, too. The figure on the right shows the largest aligned rectangle
for the depicted histogram.

 

Input

The
input contains several test cases. Each test case describes a histogram
and starts with an integer n, denoting the number of rectangles it is
composed of. You may assume that 1 <= n <= 100000. Then follow n
integers h1, ..., hn, where 0 <= hi <= 1000000000. These numbers
denote the heights of the rectangles of the histogram in left-to-right
order. The width of each rectangle is 1. A zero follows the input for
the last test case.

 

Output

For
each test case output on a single line the area of the largest
rectangle in the specified histogram. Remember that this rectangle must
be aligned at the common base line.

 

Sample Input

7 2 1 4 5 1 3 3
4 1000 1000 1000 1000
0

 

Sample Output

8
4000

 

Source

University of Ulm Local Contest 2003

 

好爽啊，用RMQ+二分解法AC了,向左边找的死循环真的困扰了我好久。。当然第二种DP解法容易写一点，但是跳跃性的思维比较难想到

解法一：RMQ+二分 时间复杂度:O(n*log(n))

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<math.h>
#include<algorithm>
using namespace std;
const int N = ;
int min_dp[N][];
long long a[N];
int L[N],R[N];
int MIN(int i,int j)
{
    if(a[i]>a[j]) return j;
    return i;
}
void init_RMQ(int n)
{
    for(int i=; i<=n; i++)
    {
        min_dp[i][]=i;
    }
    for(int j=; (<<j)<=n; j++)
    {
        for(int i=; i+(<<j)-<=n; i++)
        {
            min_dp[i][j] = MIN(min_dp[i][j-],min_dp[i+(<<(j-))][j-]);
        }
    }
}

int MIN_RMQ(int l,int r)
{
    int k=;
    while((<<(k+))<=(r-l+)) k++;
    return MIN(min_dp[l][k],min_dp[r-(<<k)+][k]);
}
int binary(int value,int l,int r) ///找到最右边
{
    while(l<=r)
    {
        if(l==r) return l;
        int mid = (l+r)>>;
        if(value<=a[MIN_RMQ(l,mid)])
        {
            l = mid+;
        }
        else r = mid;
    }

}
int binary2(int value,int l,int r) ///找到最左边
{
    while(l<r)
    {
        if(l==r-){   ///防止死循环,这里弄了好久
            if(a[r]<value) return r;  ///如果在r 并且a[r]<value 那么肯定r就是左边界
　　　　　　　return l;
        }
        int mid = (l+r)>>;
        if(value<=a[MIN_RMQ(mid,r)])
        {
            r = mid-;
        }
        else l = mid;
    }
    return l;
}
int main()
{
    int n;
    while(scanf("%d",&n)!=EOF&&n)
    {
        for(int i=; i<=n; i++)
        {
            scanf("%lld",&a[i]);
        }
        init_RMQ(n);
        L[]=;
        R[n]=n;
        for(int i=; i<=n; i++)
        {
            if(i!=n)
            {
                R[i] = binary(a[i],i+,n);
                if(R[i]==n&&a[i]<=a[n]);
                else R[i]--;
            }
            if(i!=)
            {
                L[i] = binary2(a[i],,i-);
                if(L[i]==&&a[i]<=a[]);
                else L[i]++;
            }
        }
        long long mx = -;
        for(int i=; i<=n; i++)
        {
            if((R[i]-L[i]+)*a[i]>mx) mx = (R[i]-L[i]+)*a[i];
        }
        printf("%lld\n",mx);
    }

}

解法二：DP 时间复杂度O（n*k） k是个很小的数

#include <stdio.h>
#include <iostream>
#include <string.h>
#include <math.h>
#include <algorithm>
using namespace std;
const int N = ;
long long a[N],L[N],R[N]; ///L[i]记录i点能够到达最左边的位置，R[i]同理
int main()
{
    int n;
    while(scanf("%d",&n)!=EOF&&n){
        for(int i=;i<=n;i++){
            scanf("%lld",&a[i]);
        }
        L[]=;
        R[n]=n;
        for(int i=;i<=n;i++){ ///先求出每个坐标最左边能到达的位置
            int t = i;
            while(t>&&a[i]<=a[t-]){
                t = L[t-];       ///这步相当巧妙,直接实现了跳转，如果a[t-1]不小于a[i]
                                  ///的话，我们可以断定a[t-1]的最左边肯定包含a[i]的最左边.直接跳过中间的点
                                  ///时间复杂度就肯定没有O(n*n)了,应该是O(n*k) k是个比较小的数
            }
            L[i] = t;
        }
        for(int i=n-;i>=;i--){ ///找最右边
            int t =i;
            while(t<n&&a[i]<=a[t+]){
                t = R[t+];
            }
            R[i] = t;
        }
        long long mx = -;
        for(int i=;i<=n;i++){
            if((R[i]-L[i]+)*a[i]>mx) mx = (R[i]-L[i]+)*a[i];
        }
        printf("%lld\n",mx);
    }
    return ;
}