poj3666

poj 3666 Making the Grade

题目链接：http://poj.org/problem?id=3666

参考：https://blog.csdn.net/wuyanyi/article/details/7255154

题意

给定一个序列，以最小代价将其变成单调不增或单调不减序列

问题分析

dp[i][j] := 前i+1个数构成的序列，且序列的最大值为j，dp[i][j]代表相应的cost

状态转移方程：dp[i][j]=abs(j-w[i])+min(dp[i-1][k])    (k<=j)

dp转移数组：

w[i]	i\j	1	2	3	4	5	6	7	8	9
1	0	0
3	1	2	1	0
2	2	3	1	1
4	3	6	3	2	1
5	4	10	6	4	2	1
3	5	12	7	4	3	3
9	6	20	14	10	8	7	6	5	4	3

复杂度为O(nm^2)

改进：从表格出 dp[i][j]=abs(j-w[i])+min(dp[i-1][k])   (k<=j)这里的k无需从1遍历到j，只需在对j进行for循环的时候不断更新一个dp[i-1][j]的最小值 mn=min(mn,dp[i-1][j]),然后对 dp[i][j]=abs(j-w[i])+mn 即可，改进后复杂度可变为O(nm)

但是这里的m是w[i]的最大值，显然TLE

所以必须用离散化的思想改进，复杂度变为O(n^2)

离散化：将序列排序一下，把j从原来的值映射为序列数组下标，即是用位置的前后关系来制定值

因为每次更新dp[i]只用到了dp[i]和dp[i-1]，所以可以利用滚动数组对空间复杂度进行优化

滚动数组（将两个数组滚动使用来实现重复利用）

例如：dp[i+1][j] = max(dp[i][j],dp[j-w[i]]+v[i])

这一递推式中,dp[i+1]计算时只需要dp[i]和dp[i+1]，所以可结合奇偶性写成如下形式：

int dp[2][MAX_W+1]; //dp数组
void solve()
{
	for(int i=0;i<n;i++){
		for(int j=0;j<=W;j++){
			if(j<w[i]){
				dp[(i+1)&1][j]=dp[i&1][j];
			}else{
				dp[(i+1)&1][j]=max(dp[i&1][j],dp[(i+1)&1][j-w[i]]+v[i]);
			}
		}
	}
	printf("%d\n",dp[n&1][W]);

代码

//poj3666 Marking the Grade
//给定一个序列，以最小代价将其变为单调不增或单调不减序列
//思路:DP+离散化
#include <iostream>
#include <cstdio>
#include <algorithm>
#define Abs(a) ((a>0)?(a):-(a))
using namespace std;
const int N=2005;
const long long int INF=(1<<60);
int n;
int a[N],b[N];
long long int dp[4][N];
void solve()
{
    for(int j=0;j<n;j++)
	{
		dp[0][j]= Abs(a[0]-b[j]);
	}
	for(int i=1;i<n;i++)
	{
		long long mn=dp[(i-1)&1][0];
		for(int j=0;j<n;j++)
		{
			mn=min(mn,dp[(i-1)&1][j]);
			dp[i&1][j]=Abs(a[i]-b[j])+mn;
		}
	}
	long long ans=dp[(n-1)&1][0];
	for(int i=1;i<n;i++)
		ans=min(ans,dp[(n-1)&1][i]);
	printf("%lld\n",ans);
}
int main()
{
	scanf("%d",&n);
	for(int i=0;i<n;i++)
	{
		cin>>a[i];
		b[i]=a[i];
	}
	sort(b,b+n);
	solve();
	return 0;
}