POJ 3666 Making the Grade

                  Making the Grade

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 3436		Accepted: 1608

Description

A straight dirt road connects two fields on FJ's farm, but it changes elevation more than FJ would like. His cows do not mind climbing up or down a single slope, but they are not fond of an alternating succession of hills and valleys. FJ would like to add and remove dirt from the road so that it becomes one monotonic slope (either sloping up or down).

You are given N integers A1, ... , AN (1 ≤ N ≤ 2,000) describing the elevation (0 ≤ Ai ≤ 1,000,000,000) at each of N equally-spaced positions along the road, starting at the first field and ending at the other. FJ would like to adjust these elevations to a new sequence B1, . ... , BN that is either nonincreasing or nondecreasing. Since it costs the same amount of money to add or remove dirt at any position along the road, the total cost of modifying the road is

|A1 - B1| + |A2 - B2| + ... + |AN - BN |

Please compute the minimum cost of grading his road so it becomes a continuous slope. FJ happily informs you that signed 32-bit integers can certainly be used to compute the answer.

Input

* Line 1: A single integer: N
* Lines 2..N+1: Line i+1 contains a single integer elevation: Ai

Output

* Line 1: A single integer that is the minimum cost for FJ to grade his dirt road so it becomes nonincreasing or nondecreasing in elevation.

Sample Input

7 1 3 2 4 5 3 9

Sample Output

3

Source

USACO 2008 February Gold 


解法1：n^2的DP      最优解可以不出现新的数字的，可以枚举每一位的高度

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int INF=0x3f3f3f3f;

int n,a[2013],b[2013],dp[2013],m[2013];

int abs(int a,int b) {return (a-b)>=0?(a-b):(b-a);}

bool cmp(int a,int b) {return a>b;}

int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=1;i<=n;i++) { scanf("%d",b+i); a[i]=b[i];}
        sort(b+1,b+n+1);
        memset(dp,0,sizeof(dp));
        memset(m,0,sizeof(m));
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                dp[j]=m[j]+abs(a[i]-b[j]);
                if(j>1) m[j]=min(dp[j],m[j-1]);
                else m[j]=dp[j];
            }
        }
        int ans1=INF;
        for(int i=1;i<=n;i++) ans1=min(ans1,dp[i]);
        memset(dp,0,sizeof(dp));
        memset(m,0,sizeof(m));
        sort(b+1,b+1+n,cmp);
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                dp[j]=m[j]+abs(a[i]-b[j]);
                if(j>1) m[j]=min(m[j-1],dp[j]);
                else m[j]=dp[j];
            }
        }
        int ans2=INF;
        for(int i=1;i<=n;i++) ans2=min(ans2,dp[i]);
        printf("%d
",min(ans1,ans2));
    }
    return 0;
}

解法2： 左偏树
一种贪心的解法，将数组划成很多块，每一块的最优解就是该块的中位数。。。。。 所以就是求中位数连续递增的块。。。。
         栈+左偏树维护中位数  解决。。。。

#include <iostream>
#include <cstring>
#include <cstdio>

using namespace std;

#define cls(x) memset((x),0,sizeof(x))

typedef long long int LL;

const int maxn=2013;

struct leftlistheapnode
{
    int v,d,l,r;
}heap[maxn];

int merge(int x,int y)
{
    if(!x) return y; if(!y) return x;
    if(heap[x].v<heap[y].v) swap(x,y); ///big root heap
    heap[x].r=merge(heap[x].r,y);
    int l=heap[x].l,r=heap[x].r;
    if(heap[l].d<heap[r].d) swap(heap[x].l,heap[x].r);
    if(!heap[x].r) heap[x].d=0;
    else heap[x].d=heap[r].d+1;
    return x;
}

int stk[maxn],idx,now[maxn],go[maxn],n;
LL s[maxn],b[maxn],ans[2];

int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=1;i<=n;i++) scanf("%d",&heap[i].v);
        ans[0]=ans[1]=0;
        for(int t=0;t<2;t++)
        {
            int st=t?1:n;
            int ed=t?n+1:0;
            int dd=t?1:-1;

            idx=0;
            cls(stk);cls(now);cls(go);cls(s);cls(b);
            for(int i=0;i<=n+10;i++)
            {
                heap[i].l=heap[i].d=heap[i].r=0;
            }

            for(int i=st;i!=ed;i+=dd)
            {
                ///对每一个数独立入栈
                idx++;
                stk[idx]=i;
                now[i]=1;go[i]=0;
                s[i]=heap[i].v;b[i]=0;

                while((idx>=1)&&(heap[stk[idx-1]].v>heap[stk[idx]].v))
                {
                    ///merge
                    int j=stk[idx-1],k=stk[idx];
                    stk[idx-1]=merge(j,k);
                    idx--;
                    int z=stk[idx];
                    ///update
                    s[z]=s[j]+s[k];
                    b[z]=b[j]+b[k];
                    now[z]=now[j]+now[k];
                    go[z]=go[j]+go[k];
                    if((now[z]+go[z]+1)/2<now[z])
                    {
                        stk[idx]=merge(heap[z].l,heap[z].r);
                        b[stk[idx]]=b[z]+heap[z].v;
                        s[stk[idx]]=s[z]-heap[z].v;
                        now[stk[idx]]=now[z]-1;
                        go[stk[idx]]=go[z]+1;
                    }
                }
            }
            for(int i=1;i<=idx;i++)
            {
              int j=stk[i];
              ans[t]+=(heap[j].v*(now[j]-go[j])-s[j]+b[j]);
            }
        }
        printf("%I64d
",min(ans[0],ans[1]));
    }
    return 0;
}