【S - Making the Grade】

最新推荐文章于 2022-09-08 14:24:44 发布

Masker_43

最新推荐文章于 2022-09-08 14:24:44 发布

阅读量676

点赞数 2

CC 4.0 BY-SA版权

分类专栏： ACM Virtual Judge Kuangbin专题动态规划（子类）序列与串离散化

本文链接：https://blog.youkuaiyun.com/flash403/article/details/97633884

ACM 同时被 3 个专栏收录

120 篇文章

订阅专栏

Virtual Judge

80 篇文章

订阅专栏

Kuangbin专题

80 篇文章

订阅专栏

本文探讨了在数据范围过大的情况下，如何通过离散化和动态规划解决数组优化问题。介绍了从朴素DP到使用PRESUM降低时间复杂度的过程，展示了不同优化策略的效果对比。

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

思路：

动态规划+离散化。
数据范围过大，需要离散化：A【】是原数组，U【】是去重数组，dp【】是代价。
心路历程：
1. 最核心的：每改一个数必定不会改成一个在全数组中从未出现过的新数。（dp 依据）
2. 令 dp[i][j] 代表前 i 个数符合某规则并且将最后一个元素改成数字 j 所付出的总代价，得到一个 TLE。
3. 使用滚动数组，将 dp[maxn][maxn] 改成一维，仍然 TLE。
4. 使用变量 PRESUM，降低时间复杂度。
注意：
1. 两种规则（不升\不降）只需要一次 reverse。
2. 用到的STL：unique、reserve、min_element 。

代码：

朴素dp：TLE

//TLE


#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm> 
#define INF 0x3f3f3f3f

using namespace std;

const int maxn = 2005;

int N;
int M;
int ans;
int A[maxn];
int U[maxn];
int dp[maxn][maxn]; 

int SOLVE(){
	for(int i=0;i<M;i++)
		dp[0][i] = abs(A[0] - U[i]);
	for(int i=1;i<N;i++){
		for(int j=0;j<M;j++){
			int MIN = INF;
			for(int k=0;k<=j;k++)//前面的(i-1)个数优化到全部(x)于U[j]的非(x)序列 的代价 
				MIN = min(MIN , dp[i-1][k]);
			dp[i][j] = MIN + abs(A[i] - U[j]);
		}
	}
	return *min_element(dp[N-1] , dp[N-1] + M);
}

int main(){
	cin>>N;
	for(int i=0;i<N;i++)
		cin>>A[i] , U[i] = A[i];
	sort(U , U + N);
	M = unique(U , U + N) - U;
	ans = INF;
	ans = min(ans , SOLVE());
	reverse(U , U + N);
	ans = min(ans , SOLVE());
	cout<<ans<<endl;
	return 0;
}

滚动数组：TLE

//TLE


#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm> 
#define INF 0x3f3f3f3f

using namespace std;

const int maxn = 2005;

int N;
int M;
int ans;
int A[maxn];
int U[maxn];
int dp[maxn]; 

int SOLVE(){
	memset(dp , 0 , sizeof(dp));
	for(int i=0;i<N;i++){
		for(int j=M-1;j>=0;j--){
			//注意需要改成倒序
			int MIN = INF;
			for(int k=0;k<=j;k++)//前面的(i-1)个数优化到全部(x)于U[j]的非(x)序列 的代价
				MIN = min(MIN , dp[k]);
			dp[j] = MIN + abs(A[i] - U[j]);
		}
	}
	return *min_element(dp , dp + M);
}

int main(){
	cin>>N;
	for(int i=0;i<N;i++)
		cin>>A[i] , U[i] = A[i];
	sort(U , U + N);
	M = unique(U , U + N) - U;
	ans = INF;
	ans = min(ans , SOLVE());
	reverse(U , U + N);
	ans = min(ans , SOLVE());
	cout<<ans<<endl;
	return 0;
}

PRESUM：79ms 748kB

//79ms		748kB


#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm> 
#define INF 0x3f3f3f3f

using namespace std;

const int maxn = 2005;

int N;
int M;
int ans;
int A[maxn];
int U[maxn];
int dp[maxn]; 

int SOLVE(){
	memset(dp , 0 , sizeof(dp));
	for(int i=0;i<N;i++){
		int PRESUM = INF;
		for(int j=0;j<M;j++){
			PRESUM = min(PRESUM , dp[j]);
			dp[j] = PRESUM + abs(A[i] - U[j]);
		}
	}
	return *min_element(dp , dp + M);
}

int main(){
	cin>>N;
	for(int i=0;i<N;i++)
		cin>>A[i] , U[i] = A[i];
	sort(U , U + N);
	M = unique(U , U + N) - U;
	ans = INF;
	ans = min(ans , SOLVE());
	reverse(U , U + N);
	ans = min(ans , SOLVE());
	cout<<ans<<endl;
	return 0;
}