传送门
很有训练价值的一道单调队列dp题.
状态表示很简单,dp[i][j]表示i天的时候有j股能赚到的最多的钱.
朴素的转移方程(均以买入为例):
dp[i][j] = max{dp[k][l] - (j-l)×ap[i], 1<=k<=i-w-1 && j-as[i]<=l<=j};
这个方程复杂度是O(n4)的,可以过50%数据.
优化到n3很简单,可以观察k的取值范围是1<=k<=i-w-1,只以i有关,且上界是不断扩大的,可以优化掉k那一维,用一个best[l]数组来储存出现过的最优解.
dp[i][j] = max{ best[l] - (j-l)×ap[i], j-as[i]<=l<=j. }
可是还不够,需要继续优化到n2继续观察这个转移方程可以发现 l 的取值范围是随着j增大而增大的,我们把 l 分离出来就可以用单调队列再优化一维.
dp[i][j] = max{ best[l] + l×ap[i], j-as[i]<=l<=j } - j×ap[i].
而卖出只需要类似买入反着dp一遍就可以了.
这道题整体的思维难度其实不算太大,但是一步一步的思考又需要分析清楚每一步的细节,算是一道很符合套路的题目.
代码
#pragma GCC optimize(2)
#define LL long long
#define pq priority_queue
#define ULL unsigned long long
#define pb push_back
#define mem(a,x) memset(a,x,sizeof a)
#define pii pair<int,int>
#define fir(i,a,b) for(int i=a;i<=(int)b;++i)
#define afir(i,a,b) for(int i=(int)a;i>=b;--i)
#define ft first
#define vi vector<int>
#define sd second
#define ALL(a) a.begin(),a.end()
#define bug puts("-------")
#define mpr(a,b) make_pair(a,b)
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3+10;
LL T,MaxP,w,ap[N],bp[N],as[N],bs[N],dp[N][N],q[N*2],best[N];
LL val(int i,int l){
return best[l] + l*ap[i];
}
LL f(int i,int l){
return best[l] + l*bp[i];
}
int main(){
cin >> T >> MaxP >> w;
fir(i,1,T) cin >> ap[i] >> bp[i] >> as[i] >> bs[i];
mem(dp,0x8f);
mem(best,0x8f);
LL ans = 0;
dp[0][0] = 0;
best[0] = 0;
fir(i,1,T){
if(i-w-1>=1){
fir(j,0,MaxP){
best[j] = max(best[j],dp[i-w-1][j]);
}
}
int l = 1,r = 0;
fir(j,0,MaxP){
dp[i][j] = dp[i-1][j];
while(l <= r && q[l] < j-as[i]) l++;
while(l <= r && val(i,j) >= val(i,q[r])) r--;
q[++r] = j;
if(l <= r)
dp[i][j] = max(dp[i][j],val(i,q[l])-j*ap[i]);
ans = max(ans,dp[i][j]);
}
l = 1,r = 0;
afir(j,MaxP,0){
while(l <= r && q[l] > bs[i]+j) l++;
while(l <= r && f(i,j) >= f(i,q[r])) r--;
q[++r] = j;
if(l <= r)
dp[i][j] = max(dp[i][j],f(i,q[l]) - j*bp[i]);
ans = max(ans,dp[i][j]);
}
}
cout << ans << endl;
return 0;
}
/*
买入 dp[i][j] = max{dp[k][l] - (j-l)*ap[i], 1<=k<=i-w-1 && j-as[i]<=l<=j};
1. dp[i][j] = best[l] - (j-l)*ap[i], j-as[i]<=l<=j.
2. dp[i][j] = best[l] + l*ap[i] - j*ap[i].
i-w-1 newdecision ->
卖出 dp[i][j] = max(dp[k][l] + (l-j)*bp[i], 1<=k<=i-w-1 && j<=l<=bs[i]+j)
1. dp[i][j] = best[l] + (l-j)*bp[i].
2. dp[i][j] = best[l] + l*bp[i] - j*bp[i].
*/