poj 3666 Making the Grade（dp离散化）

Making the Grade

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 7068		Accepted: 3265

Description

A straight dirt road connects two fields on FJ's farm, but it changes elevation more than FJ would like. His cows do not mind climbing up or down a single slope, but they are not fond of an alternating succession of hills and valleys. FJ would like to add and remove dirt from the road so that it becomes one monotonic slope (either sloping up or down).

You are given N integers A₁, ... , A_N (1 ≤ N ≤ 2,000) describing the elevation (0 ≤ A_i ≤ 1,000,000,000) at each of N equally-spaced positions along the road, starting at the first field and ending at the other. FJ would like to adjust these elevations to a new sequence B₁, . ... , B_N that is either nonincreasing or nondecreasing. Since it costs the same amount of money to add or remove dirt at any position along the road, the total cost of modifying the road is

|A₁ - B₁| + |A₂ - B₂| + ... + |A_N - B_N |

Please compute the minimum cost of grading his road so it becomes a continuous slope. FJ happily informs you that signed 32-bit integers can certainly be used to compute the answer.

Input

* Line 1: A single integer: N
* Lines 2..N+1: Line i+1 contains a single integer elevation: A_i

Output

* Line 1: A single integer that is the minimum cost for FJ to grade his dirt road so it becomes nonincreasing or nondecreasing in elevation.

Sample Input

7
1
3
2
4
5
3
9

Sample Output

3

 

 

给定一个序列，以最小代价将其变成单调不增或单调不减序列，这里的代价看题目公式。

思路：

很容易想到是DP。

1.

对前i个序列，构成的最优解其实就是与两个参数有关。一个是这个序列处理后的最大值mx，和这个序列处理的代价值cost。

显然最大值mx最小最好（这样第i+1个值可以不花代价直接接在其后面的可能性更大），cost最小也最好（题意要求），但是两者往往是鱼和熊掌。

用dp[i][j]表示：前i个数构成的序列，这个序列最大值为j，dp[i][j]的值代表相应的cost。

所以状态转移方程如下：

dp[i][j]=abs(j-w[i])+min(dp[i-1][k]);(k<=j)

这个表格是根据转移方程写出来的dp数组。

再仔细看一下转移方程：dp[i][j]=abs(j-w[i])+min(dp[i-1][k]);(k<=j)

右边没填充的是因为填充的数字肯定比前面的数字大，无用，因为在求min( dp[i-1][k] )时，是求最小值，既然更大，则最小值时无需考虑。

又从表格中可以看出：

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(NMM)改进为O(NM);

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

所以必须用离散化思想改进，因为N=2000。远小于A[i]的最大值。

离散化：将序列排序一下，然后用位置的前后关系来制定其值，这样时间复杂度变成O(N^2).

最后是这题数据有bug，只需要求不减序列即可。

？：谁能给我讲讲为什么这样离散化？为什么最后的结果中的每一个的数字都在原来的串中出现过？为什么这样得到的就是一个最优解？

附个解题报告，没太看懂他的证明

http://www.cnblogs.com/vb4896/p/5877962.html

#include<iostream>
#include <cstdio>
#include<vector>
#include<algorithm>
#define Abs(a) ((a)>0?(a):-(a))
#define Mod(a,b) (((a)-1+(b))%(b)+1)
using namespace std;
const int N=2005;
const long long inf=(1<<60);
int n;
int a[N],b[N];
long long int dp[N][N];
void solve()
{
    for(int i=1;i<=n;i++)
    {
        long long mn=dp[i-1][1];
        for(int j=1;j<=n;j++)
        {
            mn=min(mn,dp[i-1][j]);
            dp[i][j]=Abs(a[i]-b[j])+mn;
        }
    }
    long long ans=dp[n][1];
    for(int i=1;i<=n;i++)
        ans=min(ans,dp[n][i]);
    printf("%lld
",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+n+1);
    solve();
    
    return 0;
}

题目给出了一列数，要求通过修改某些值，使得最终这列数变成有序的序列，非增或者非减的（数据很弱，只用求非严格递增即可），求最小的修改量。

首先我们会发现，最终修改后，或者和前一个数字一样，或者和后一个数字一样，这样才能修改量最小。

我们先根据原数列排序，确定元素的大小关系，对应编号为p[i]

dp[i][j] 表示考虑前i个元素，最后元素为序列中 第j小元素的最优解

dp[i][j] = MIN(dp[i-1][k]) + abs(a[i]-a[p[j]]), (0<k<=j)    // 非严格递增

//二维解法
#include<iostream>
#include <cstdio>
#include<cmath>
#include<algorithm>
using namespace std;
const int N=2010;

int n;
__int64 a[N];
__int64 b[N];

bool cmp(__int64 a,__int64 b)
{
    return a<b;
}

__int64 dp[N][N];
__int64 min(__int64 x,__int64 y)
{
    return x<y?x:y;
}
int main()
{
    //freopen("in.txt","r",stdin);
    __int64 i,j,k,ans;
    cin>>n;
    for(i=1; i<=n; i++) {
        scanf("%I64d",&a[i]);
    }
    for(i=1; i<=n; i++) {
        b[i]=a[i];
    }
    sort(b+1,b+1+n,cmp);
    for(j=1; j<=n; j++) {
        dp[1][j]=a[1]-b[j];
        if(dp[1][j]<0) {
            dp[1][j]=-dp[1][j];
        }
    }
    __int64 t;
    for(i=2; i<=n; i++) { // 非严格递增
        k=dp[i-1][1];
        for(j=1; j<=n; j++) {
            k=min(dp[i-1][j],k);
            t=a[i]-b[j];
            if(t<0) {
                t=-t;
            }
            dp[i][j]=k+t;   //dp[i][j] = min{dp[i - 1][0...j] + ?abs(a[i] - b[j])}
        }
    }
    ans=dp[n][n];
    for(i=n; i>=1; i--) {
        ans=min(ans,dp[n][i]);
    }
    printf("%I64d
",ans);
    return 0;
}

//一维 （滚动数组）
#include<iostream>
#include <cstdio>
#include<cmath>
#include<algorithm>
using namespace std;
const int N=2010;
__int64 a[N],b[N],dp[2][N];
__int64 min(__int64 x,__int64 y)
{
    return x<y?x:y;
}
int main()
{
    int n,i,j;
    __int64 k,t;
    scanf("%d",&n);
    for(i=1; i<=n; i++) {
        scanf("%I64d",&a[i]);
    }
    for(i=1; i<=n; i++) {
        b[i]=a[i];
    }
    sort(b+1,b+1+n);
    for(i=1; i<=n; i++) {
        dp[0][i]=a[1]-b[i];
        if(dp[0][i]<0) {
            dp[0][i]=-dp[0][i];
        }
    }
    for(i=2; i<=n; i++) {
        k=dp[i%2][1];
        for(j=1; j<=n; j++) {
            k=min(k,dp[i%2][j]);
            t=a[i]-b[j];
            if(t<0) {
                t=-t;
            }
            dp[(i+1)%2][j]=k+t;
        }
    }
    j=(n+1)%2;
    k=dp[j][1];
    for(i=2; i<=n; i++) {
        k=min(k,dp[j][i]);
    }
    printf("%I64d
",k);
    return 0;
}