dp+贪心+滚动优化

题目

Making the Grade POJ - 3666
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 A1, … , AN (1 ≤ N ≤ 2,000) describing the elevation (0 ≤ Ai ≤ 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 B1, . … , BN 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

|A1 - B1| + |A2 - B2| + … + |AN - BN |
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: Ai

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[i][j]记录的是用1~10000000000的数字去替换第i个数且让前i数非递减所付出的最小代价之和则 状态转移方程为dp[i][j]=min(dp[i-1][k])+abs(a[i]-b[j])(k=1,2,3…k)(因为前i个数的最大值不可能比j大)
但是10亿太大必超时；
这时有一种贪心的方法：在每一步的修改中为了尽量让代价最小会将被修改的这个数修改成 在这个数两侧 ，离这个数值，最近的那个数；修改后的数列a’[i]中的数值肯定都是a[]中的数值；
这些数最多2000多个；因此不妨离散化成b【i】(要排序)(只含a[i]中数值的升序列),

快捷键目录标题文本样式列表链接代码片表格注脚注释自定义列表LaTeX 数学公式插入甘特图插入UML图插入Mermaid流程图插入Flowchart流程图插入类图

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
bool cmp(long a,long b)
{
	return a<b;
}
long long  a[11010],b[11010];
long long  dp[2021][2021];
long long  dp2[2021];
long long abs1(long long x)
{
	if(x<0)
		x=-x;
	return x;
}
int main()
{
	long long  n,m,j,i,k,L,w,min1,min2;

	scanf("%lld",&w);
	for(i=1; i<=w; i++)
	{
		scanf("%lld",&a[i]);
		b[i]=a[i];
	}

	sort(b+1,b+w+1);


	/*	for(i=1; i<=w; i++)
		{
			for(j=1; j<=w; j++)
			{
				min1=dp[i-1][1];
				for(k=1; k<=j; k++)//可以用一个数维护前dp[i-1][j]的最小
				//值(只需要让新遍历的dp[i-1][j]跟前j-1个所维护的最小值比可省去此循环)
				{
					min1=min(dp[i-1][k],min1);
				}
				dp[i][j]=min1+abs(b[j]-a[i]);
			}
		}*/
	/*维护优化后*/
	/*	for(i=1; i<=w; i++)
		{
			min1=dp[i-1][1];//dp[i][j]的值只跟dp[i-1][j]有关可用滚动数组优化减少内存
			for(j=1; j<=w; j++)
			{
				min1=min(min1,dp[i-1][j]);
				dp[i][j]=min1+abs(b[j]-a[i]);
			}
		}*/

	/*滚动数组*/
	for(i=1; i<=w; i++)
	{
		min1=dp2[1];
		for(j=1; j<=w; j++)
		{
			min1=min(min1,dp2[j]);
			dp2[j]=min1+abs1(a[i]-b[j]);
		}
	}
	min2=dp2[1];
	for(i=1; i<=w; i++)
	{
		min2=min(dp2[i],min2);
	}
	/*
	for(j=1; j<=w; j++)
	{
		min2=min(min2,dp[w][j]);
	}*/

	printf("%lld",min2);
	return 0;
}