Codeforces Round #256 (Div. 2) C. Painting Fence（分治+贪心）（好题）

http://codeforces.com/contest/448/problem/C

C. Painting Fence

time limit per test

1 second

memory limit per test

512 megabytes

input

standard input

output

standard output

Bizon the Champion isn't just attentive, he also is very hardworking.

Bizon the Champion decided to paint his old fence his favorite color, orange. The fence is represented as n vertical planks, put in a row. Adjacent planks have no gap between them. The planks are numbered from the left to the right starting from one, the i-th plank has the width of 1 meter and the height of ai meters.

Bizon the Champion bought a brush in the shop, the brush's width is 1 meter. He can make vertical and horizontal strokes with the brush. During a stroke the brush's full surface must touch the fence at all the time (see the samples for the better understanding). What minimum number of strokes should Bizon the Champion do to fully paint the fence? Note that you are allowed to paint the same area of the fence multiple times.

Input

The first line contains integer n (1 ≤ n ≤ 5000) — the number of fence planks. The second line contains n space-separated integersa1, a2, ..., an (1 ≤ ai ≤ 109).

Output

Print a single integer — the minimum number of strokes needed to paint the whole fence.

Sample test(s)

input

5
2 2 1 2 1

output

3

input

2
2 2

output

2

input

1
5

output

1

Note

In the first sample you need to paint the fence in three strokes with the brush: the first stroke goes on height 1 horizontally along all the planks. The second stroke goes on height 2 horizontally and paints the first and second planks and the third stroke (it can be horizontal and vertical) finishes painting the fourth plank.

In the second sample you can paint the fence with two strokes, either two horizontal or two vertical strokes.

In the third sample there is only one plank that can be painted using a single vertical stroke.

大致题意“：

宽度为1的竖着放置的长木板（像数轴上的条形图），用宽度为1的刷子进行涂色，刷子必须严格在长木板内才能连续刷，问最少连续刷多少次

搞了50min最后wa了，差了一点可惜

注意到这几点就可以有思路了：

1.一旦横着刷，就一刷到底直到遇到边界，这时肯定不比刷到一半再竖着刷的解差

2.对于最底部的最大的矩形来说，要么全竖着刷满，要么全横着刷满，因为假设竖着刷一部分再横着刷一部分，用横着刷的那些轨迹继续延长就可以刷满整个最大的矩形，也就是贪心1保证了这点

所以选这两个决策中的最小解就可以了，然后就在这里wa了，显然全竖着刷的次数为区间长度（R-L），用横着刷的时候不仅仅是minh次，因为同时还要计算原来的条形图减去底部最大矩形后再涂满需要的次数，这时候是重复子问题，分治即可

#include <iostream>
#include <cstring>
#include <cmath>
#include <queue>
#include <stack>
#include <list>
#include <map>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#include <cstdio>
#include <ctime>
#include <bitset>
#include <algorithm>
#define SZ(x) ((int)(x).size())
#define ALL(v) (v).begin(), (v).end()
#define foreach(i, v) for (__typeof((v).begin()) i = (v).begin(); i != (v).end(); ++ i)
#define REP(i,n) for ( int i=1; i<=int(n); i++ )
using namespace std;
typedef long long ll;
const int inf = 0x3f3f3f3f;
const int N = 5123;
int h[N];
int n;

ll cal(int l,int r)
{
    int minn = inf;
    for(int i=l;i<=r;i++) minn = min(minn,h[i]);
    for(int i=l;i<=r;i++) h[i]-=minn;
    ll ans = minn;
    bool flag=0;
    int L,R;
    for(int i=l;i<=r+1;i++)
    {
        if(h[i] && flag == 0)
        {
            flag=1;
            L = i;
        }
        else if(flag && h[i] == 0)
        {
            R = i-1;
            ans += cal(L,R);<span style="white-space:pre">		</span>//分治解决子问题
            flag = 0;
        }
    }
    return min((ll)r-l+1,ans);<span style="white-space:pre">	</span>//取两个决策中次数最少的
}

int main()
{
    cin>>n;
    REP(i,n) cin>>h[i];
    cout<<cal(1,n)<<endl;
}