[BZOJ 1592] Making The Grade路面修整

1592: [Usaco2008 Feb]Making the Grade 路面修整

Time Limit: 10 Sec  Memory Limit: 162 MB
Submit: 704  Solved: 483
[Submit][Status][Discuss]

Description

FJ打算好好修一下农场中某条凹凸不平的土路。按奶牛们的要求，修好后的路面高度应当单调上升或单调下降，也就是说，高度上升与高度下降的路段不能同时出现在修好的路中。 整条路被分成了N段，N个整数A_1, ... , A_N (1 <= N <= 2,000)依次描述了每一段路的高度(0 <= A_i <= 1,000,000,000)。FJ希望找到一个恰好含N个元素的不上升或不下降序列B_1, ... , B_N，作为修过的路中每个路段的高度。由于将每一段路垫高或挖低一个单位的花费相同，修路的总支出可以表示为： |A_1 - B_1| + |A_2 - B_2| + ... + |A_N - B_N| 请你计算一下，FJ在这项工程上的最小支出是多少。FJ向你保证，这个支出不会超过2^31-1。

Input

* 第1行: 输入1个整数：N * 第2..N+1行: 第i+1行为1个整数：A_i

Output

* 第1行: 输出1个正整数，表示FJ把路修成高度不上升或高度不下降的最小花费

Sample Input

7
1
3
2
4
5
3
9

Sample Output

3

HINT

FJ将第一个高度为3的路段的高度减少为2，将第二个高度为3的路段的高度增加到5，总花费为|2-3|+|5-3| = 3，并且各路段的高度为一个不下降序列 1,2,2,4,5,5,9。

这题显然是个 $DP$ ...

首先我们可以设置记忆化数组 $f_{i,j}$ ,代表前 $i$ 步可以取得的最大高度为 $j$ .因为高度的范围比较大但是数据个数不多所以考虑离散化一发.

离散化之后 $DP$ 转移方程还算明确

\[ f_{i,j}=min( f_{i,j-1}, f_{i-1,j}+ \left | a_i - b_j \right | )\]

其中 $a_i$ 为第 $i$ 个路段的高度, $b_i$ 的意义是若某路段的高度在离散化后的结果为 $i$ ,则原数据为 $b_i$ .

然后由于题目要求可以单调不降或者单调不升, 所以应该扫描两遍然后取较小答案, 枚举 $j$ 时要一次正向一次反向.

然后参考代码如下:

GitHub

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

const int MAXN=2010;
const int INF=0x3FFFFFFF;

int n;
int m;
int data[MAXN];
int hash[MAXN];
int dp[MAXN][MAXN];

int Hash(int);
void Initialize();
int DynamicProgramming();

int main(){
    Initialize();
    printf("%d\n",DynamicProgramming());
    return 0;
}

int DynamicProgramming(){
    memset(dp,0x3F,sizeof(dp));
    memset(dp[0],0,sizeof(dp[0]));
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            dp[i][j]=std::min(dp[i-1][j]+abs(hash[j]-data[i]),dp[i][j-1]);
        }
    }
    int ans=dp[n][m];
    memset(dp,0x3F,sizeof(dp));
    memset(dp[0],0,sizeof(dp[0]));
    for(int i=1;i<=n;i++){
        for(int j=m;j>0;j--){
            dp[i][j]=std::min(dp[i-1][j]+abs(hash[j]-data[i]),dp[i][j+1]);
        }
    }
    ans=std::min(ans,dp[n][1]);
    return ans;
}

void Initialize(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d",data+i);
    }
    memcpy(hash,data,sizeof(data));
    std::sort(hash+1,hash+n+1);
    m=std::unique(hash+1,hash+n+1)-(hash+1);
}

inline int Hash(int x){
    return std::lower_bound(hash+1,hash+m+1,x)-hash;
}