[DP] POJ 3666

题意

农夫约翰想修一条尽量平缓的路，路的每一段海拔是A_i，修理后是B_i，花费|A_i – B_i|，求最小花费。

思路

不知道是不是数据问题，只要求上升序列的最小花费就行了
http://www.hankcs.com/program/cpp/poj-3666-making-the-grade.html
dp[i][j] = min(dp[i – 1][k]) + |A[i] – B[j]|
要使花费最小，那么修改后的海拔要么和前一个相等，要么和后一个相等。这样才能保证花费最小。
所以修改后的数一定是在原本序列之中的某一个数
我们复制一个最初的数组，将他排序，每次都遍历选择当前值修正后的值，（而不是枚举所有可行的值）并且保证cost最小（这里用离散化的思想）
在就是用一个mi来记录前dp[i-1][k]的最小值
最后用滚动数组优化

代码

#include <algorithm>
#include <iostream>
#include <stdio.h>
#include <string.h>

#define N 2200

using namespace std;

int n;
//滚动，pre = dp[ i-1 ]
long long dp[ N ], pre[ N ];
int a[ N ], b[ N ];

void solve () {
    memset ( dp, 0, sizeof ( dp ) );
    memset ( pre, 0, sizeof ( pre ) );
    for ( int i = 1; i <= n; ++i ) {
        //储存 dp[i-1][0...j]的最小值
        long long mi = pre[ 1 ];
        for ( int j = 1; j <= n; ++j ) {
            mi = min ( mi, pre[ j ] );
            //把末尾的数字变成其中的一种，并取最优的那种变化
            // dp[ i ][ j ] = abs ( a[ i ] - b[ j ] ) + min ( dp[ i - 1 ][ k ] );
            // dp[ i ][ j ] += abs ( a[ i ] - b[ j ] ) + mi;
            dp[ j ] = abs ( a[ i ] - b[ j ] ) + mi;
            pre[ j ] = dp[ j ];
        }
    }
    long long ans = dp[ 1 ];
    for ( int i = 1; i <= n; ++i )
        ans = min ( ans, dp[ i ] );
    printf ( "%lld\n", ans );
}

int main () {
    while ( ~scanf ( "%d", &n ) ) {
        for ( int i = 1; i <= n; ++i ) {
            scanf ( "%d", &a[ i ] );
            b[ i ] = a[ i ];
        }
        //每个值都可以变成任意该序列里存在的值才会保证最小
        sort ( b + 1, b + 1 + n );
        solve ();
    }
    return 0;
}