Making the Grade POJ - 3666 （将一个数组变成严格&不严格，不递增&不递减的数组的最小代价）

本文链接：https://blog.csdn.net/I_have_a_world/article/details/117454499

题意：给定一个数n(1<=n<=2000)，然后是一个长度为n的数组a（0<=ai<=1e9）。ai改为bi的代价为abs(ai-bi)，求将一个数组变为不严格不递增或者不严格不递减数组的代价。

题解：

为什么离散化正确：因为不严格，所以每次改变一定是变为a[i-1]或者a[i+1]是最优的情况
如果严格：那就会麻烦一点点的样子，可以先ai-=i，然后就变成了不严格的单调数组了
不严格单调增：dp[i][j]表示前 i 个数中最大值为 mp[j] 的最小操作数。状态转移方程为： $dp[i][j]=dp[i-1][1...j]+abs(mp[j]-a[i])$ ,mp[j]表示第 j 小的数
不严格单调减：dp[i][j]表示后面 i~n 中最小值为 mp[j] 的最小操作数。状态转移方程为： $dp[i][j]=dp[i+1][1...j]+abs(mp[j]-a[i])$ ,mp[j]表示第 j 小的数
时间复杂度：O(n^2)

代码：

#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <string>
#define int long long
using namespace std;
const int N = 2e3 + 10;
const int INF = 1e18;

int n, a[N], b[N];
int cnt;
int mp[N];
int dp[N][N];
signed main() {
    cin >> n;
    int i, j, mi, ans = INF;
    for (i = 1; i <= n; i++) cin >> a[i], b[i] = a[i];
    sort(b + 1, b + 1 + n);
    b[0] = -1;  //如果b[1]=0，那么mp[1]=0
    for (i = 1; i <= n; i++) {
        if (b[i] == b[i - 1])
            continue;
        else
            mp[++cnt] = b[i];
    }
    // dp[i][j]表示前i个数中，最大值刚好为mp[j]的最小操作数——单增
    for (j = 1; j <= cnt; j++) dp[1][j] = abs(mp[j] - a[1]);
    for (i = 2; i <= n; i++) {
        mi = INF;
        for (j = 1; j <= cnt; j++) {
            mi = min(mi, dp[i - 1][j]);
            dp[i][j] = mi + abs(a[i] - mp[j]);
        }
    }
    for (j = 1; j <= cnt; j++) ans = min(ans, dp[n][j]);
    // cout << ans << endl;
    // return 0;
    //单减：i~n个数最小值为mp[j]
    for (j = cnt; j >= 1; j--) dp[n][j] = abs(mp[j] - a[n]);
    for (i = n - 1; i >= 1; i--) {
        mi = INF;
        for (j = cnt; j >= 1; j--) {
            mi = min(mi, dp[i + 1][j]);
            dp[i][j] = mi + abs(a[i] - mp[j]);
        }
    }
    for (j = cnt; j >= 1; j--) ans = min(ans, dp[1][j]);
    cout << ans << endl;
    return 0;
}
/*
input:::
7
1 3 2 4 5 3 9
output:::
3
*/