POJ ~ 3666 ~ Making the Grade (DP + 离散化)

本文介绍了一种使用动态规划的方法来解决将序列调整为单调不递增或单调不递减的问题,并逐步优化算法,最终达到n^2的时间复杂度。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

题意:给你一个长度为n(n<=2000)序列,问将其变成单调不递增或单调不递减的序列的最小改动的值为多少?

思路:两种单调性情况,求得一种,把数组反序再求一遍另一种就好了。可以想得到DP,我们就一步步往下考虑。
首先定义状态dp[i][j]dp[i][j] 表示前ii个数字以 j 这个数字结尾的时候的答案。
不难想到状态转移方程dp[i][j]=min(dp[i1][k])+abs(ja[i]),(1in)(0kj)(0j1e9)dp[i][j]=min(dp[i−1][k])+abs(j−a[i]),(1≤i≤n)(0≤k≤j)(0≤j≤1e9) 其中 a 是题目中给的数列,答案为 min(dp[n][j]),(0j1e9)min(dp[n][j]),(0≤j≤1e9)
jj 太大了想办法搞一下,因为 n 很小只有2000,任何时候 jj 的最优情况只可能是 a 数组中的数字。因为对于原序列的某个数字,一定要变成该序列中的某个数字,才是最优解。(好像是废话…)。那么 j 的取值范围就大大的缩小了,变为原序列中的某个数字,只有2000个,因为求解的时候我们需要 kjk≤j ,所以我们把这个 jj 的取值搞到一个新的数组 b 中,进行排序,其实这里就是对 jj 离散化了一下。
所以,dp方程变为:dp[i][j]=min(dp[i1][k])+abs(b[j]a[i]),(1kj)(1jn)
我们现在发现仍然需要3重for,复杂度为 n3n3 会超时,我们不妨先把这个想法敲一下,然后看哪里能优化。

超时版!!!:

//#include<bits/stdc++.h>
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAXN = 2005;
const int INF = 0x3f3f3f3f;
int n, a[MAXN], b[MAXN], dp[MAXN][MAXN];
int work()
{
    memset(dp, 0, sizeof(dp));
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            int MIN = INF;
            for (int k = 1; k <= j; k++)
            {
                MIN = min(MIN, dp[i-1][k]);
            }
            dp[i][j] = MIN + abs(a[i]-b[j]);
        }
    }
    int ans = INF;
    for (int i = 1; i <= n; i++) ans = min(ans, dp[n][i]);
    return ans;
}
int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &a[i]);
        b[i] = a[i];
    }
    sort(b+1, b+1+n);
    int ans = INF;
    ans = min(ans, work());
    reverse(b+1, b+1+n);//翻转再求
    ans = min(ans, work());
    printf("%d\n", ans);
    return 0;
}

/*
7
1 3 2 4 5 3 9
*/

我们发现好像最内层的for循环没起到很大的作用,只是求了一个最小值,且 k 是随着 j 在变化的,j 增加1,k就要从1 遍历到 j ,然而我们之前都求过1~(j-1)的最小值了只差跟 dp[i1][j]dp[i−1][j] 的比较一下。我们其实完全可以用一个变量MIN维护 min(dp[i1][k])(1kj)min(dp[i−1][k])(1≤k≤j) 这个值,将 k 和 j 的循环融合到一起。
这样就完全OK了,复杂度为 n2n2 ,空间复杂度为 n2n2
AC代码:

//#include<bits/stdc++.h>
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAXN = 2005;
const int INF = 0x3f3f3f3f;
int n, a[MAXN], b[MAXN], dp[MAXN][MAXN];
int work()
{
    memset(dp, 0, sizeof(dp));
    for (int i = 1; i <= n; i++)
    {
        int MIN = INF;
        for (int j = 1; j <= n; j++)
        {
            MIN = min(MIN, dp[i-1][j]);
            dp[i][j] = abs(a[i]-b[j])+MIN;
        }
    }
    int ans = INF;
    for (int i = 1; i <= n; i++) ans = min(ans, dp[n][i]);
    return ans;
}
int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &a[i]);
        b[i] = a[i];
    }
    sort(b+1, b+1+n);
    int ans = INF;
    ans = min(ans, work());
    reverse(b+1, b+1+n);
    ans = min(ans, work());
    printf("%d\n", ans);
    return 0;
}

/*
7
1 3 2 4 5 3 9
*/

虽然已经AC了,但是还能在优化,每次dp[i][j]的状态只和dp[i-1][j] 有关,我们可以用滚动数组优化一下空间,将空间复杂度变为 nn
AC代码

//#include<bits/stdc++.h>
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAXN = 2005;
const int INF = 0x3f3f3f3f;
int n, a[MAXN], b[MAXN], dp[2][MAXN];
int work()
{
    memset(dp, 0, sizeof(dp));
    for (int i = 1; i <= n; i++)
    {
        int MIN = INF;
        for (int j = 1; j <= n; j++)
        {
            MIN = min(MIN, dp[(i-1)%2][j]);
            dp[i%2][j] = abs(a[i]-b[j])+MIN;
        }
    }
    int ans = INF;
    for (int i = 1; i <= n; i++) ans = min(ans, dp[n%2][i]);
    return ans;
}
int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &a[i]);
        b[i] = a[i];
    }
    sort(b+1, b+1+n);
    int ans = INF;
    ans = min(ans, work());
    reverse(b+1, b+1+n);
    ans = min(ans, work());
    printf("%d\n", ans);
    return 0;
}

/*
7
1 3 2 4 5 3 9
*/
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值