【POJ 3666】Making the Grade（离散化+DP）

【POJ 3666】Making the Grade（离散化+DP）

题目大意：
给出长为n的序列，每次可以选择其中一个元素 +1或-1
问至少几次这种操作，能够将序列变为单调不增或不减序列？

元素可以为负。

先来求单调不增序列最少操作次数。不减其实也就一样了。
考虑 dp[i][j] 为把1~i变为单调不增序列，且第i个元素变为j所需要的最少操作。
这样 dp[i][j]=maxk=1jdp[i−1][k]
因为转移要求 a[1,2,3,...,i−1]≤a[i] ，保证结尾其实也就保证前缀了，那么在结尾合法的状态下找到最少步数即可。
这样从左往右扫一遍就出来答案了。

因为元素数值10^9，因此考虑离散化，只记录出现过的元素。因为如果变为未出现过的元素是没有意义的。无论从哪个元素移动到未出现的元素，都不如移动到该元素左或右出现过的元素。

譬如 a[j]<x<a[j+1](a数组已排序离散化) 那么无论从a中哪个元素转移到x，都不如到j和j+1中距离较近的步数少。

复杂度 O(nm) m为离散化后的元素数量

代码如下：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define LL long long
#define Pr pair
#define fread(ch) freopen(ch,"r",stdin)
#define fwrite(ch) freopen(ch,"w",stdout)

using namespace std;
const int INF = 0x3f3f3f3f;
const int msz = 10000;
const int mod = 1e9+7;
const double eps = 1e-8;

int dp[2][2333][2333];
int a[2333];
int b[2333];
map <int,int> mp;

int main()
{
    //fread("");
    //fwrite("");

    int n;

    scanf("%d",&n);

    for(int i = 0; i < n; ++i)
    {
        scanf("%d",&a[i]);
        b[i] = a[i];
    }

    sort(b,b+n);

    int id = -1;
    for(int i = 0; i < n; ++i)
    {
        if(i == 0 || b[i] != b[i-1])
        {
            id++;
            b[id] = b[i];
            mp[b[i]] = id;
        }
    }

    memset(dp,INF,sizeof(dp));

    for(int i = 0; i <= id; ++i)
    {
        dp[0][0][i] = dp[1][0][i] = abs(a[0]-b[i]);
        if(i) 
        {
            dp[0][0][i] = min(dp[0][0][i],dp[0][0][i-1]);
            dp[1][0][i-1] = min(dp[1][0][i-1],dp[1][0][i]);
        }
    }

    for(int i = 1; i < n; ++i)
    {
        for(int j = 0; j <= id; ++j)
        {
            dp[0][i][j] = dp[0][i-1][j]+abs(a[i]-b[j]);
            dp[1][i][j] = dp[1][i-1][j]+abs(a[i]-b[j]);

            if(j)
            {
                dp[0][i][j] = min(dp[0][i][j],dp[0][i][j-1]);
                dp[1][i][j-1] = min(dp[1][i][j-1],dp[1][i][j]);
            }
        }
    }

    printf("%d\n",min(dp[0][n-1][id],dp[1][n-1][0]));

    return 0;
}