洛谷P2569 [SCOI2010]股票交易（单调队列优化DP）

题目链接：P2569 [SCOI2010]股票交易

题解：用dp[i][j]表示第i天结束时拥有j数量股票时的最大收益，对于每天，我们把可以进行的操作分成4类：

1.之前都没有买入股票，今天第一次买入，此时直接计算得出dp[i][j]=-j*AP

2.今天不操作，显然可得状态转移方程dp[i][j]=max(dp[i][j],dp[i-1][j])

3.在原有股票基础上买入后今天持有j股，那么我们就需要在[1,i-w-1]（i-w-1是因为两次操作至少间隔w天）中查找一天作为转移，显然，因为操作2，使得最优的那天一定为i-w-1（即dp[i-w-1][j]>=dp[i][j]，1<=i<=i-w-1）,此时我们只需要考虑转移前持有的股票数量k，显然j-AS<=k<=j,状态转移方程：dp[i][j]=dp[i-w-1][k]-(j-k)*AP=dp[i-w-1][k]+k*AP-j*AP，此时我们查找的k即为使得dp[i-w-1][k]+k*AP最大的k,这里用单调队列存放第j-w-1天拥有的股票数k，满足队列内按dp[i-w-1][k]+k*AP降序，这样每次队首存放的即为最优转移的k

4.在原有股票基础上卖出后今天持有j股，这里和操作3基本一致，因为状态转移方程：dp[i][j]=dp[i-w-1][k]+(k-j)*BP=dp[i-w-1][k]+k*BP-j*BP，用单调队列存放第j-w-1天拥有的股票数k，满足队列内按dp[i-w-1][k]+k*BP降序，这样每次 队头首存放的即为最优转移的k

细节和不懂可以看代码，注释依旧很详细：

#include<iostream>
#include<stack>
#include<list>
#include<set>
#include<vector>
#include<algorithm>
#include<math.h>
#include<numeric>
#include<map>
#include<cstring>
#include<queue>
#include<iomanip>
#include<cmath>
#include<queue>
#include <bitset>
#include<unordered_map>
	#ifndef local
	#define endl '\n'
#endif */
#define mkp make_pair
using namespace std;
using std::bitset;
typedef long long ll;
typedef long double ld;
const int inf=0x3f3f3f3f;
const ll MAXN=2e6+10;
const ll INF=1e18;
const ll N=2e5+100;
const ll mod=1e9+7;
const ll hash_p1=1610612741;
const ll hash_p2=805306457;
const ll hash_p3=402653189;
//-----------------------------------------------------------------------------------------------------------------*/
// ll head[MAXN],net[MAXN],to[MAXN],edge[MAXN]/*流量*/,cost[MAXN]//费用;
/* 
void add(ll u,ll v,ll w,ll s){
	to[++cnt]=v;net[cnt]=head[u];edge[cnt]=w;cost[cnt]=s;head[u]=cnt;
	to[++cnt]=u;net[cnt]=head[v];edge[cnt]=0;cost[cnt]=-s;head[v]=cnt;
}
struct elemt{
	int p,v;
};
-----------------------------------
求[1,MAXN]组合式和逆元 
ll mi(ll a,ll b){
	ll res=1;
	while(b){
		if(b%2){
			res=res*a%mod;
		}	
		a=a*a%mod;
		b/=2;
	}
	return res;
}
ll fac[MAXN+10],inv[MAXN+10]
ll C(int m,int n){//组合式C(m,n); 
	if(!n){
		return 1;
	}
	return fac[m]*(inv[n]*inv[m-n]%mod)%mod;
}
fac[0]=1;inv[0]=1;
for(ll i=1;i<=MAXN;i++){
	fac[i]=(fac[i-1]*i)%mod;
	inv[i]=mi(fac[i],mod-2);
}
---------------------------------
 unordered_map<int,int>mp;
//优先队列默认小顶堆 ， greater<int> --小顶堆  less<int> --大顶堆  
priority_queue<elemt,vector<elemt>,comp>q;
struct comp{
	public:
		bool operator()(elemt v1,elemt v2){
			return v1.v<v2.v;
		}
};
	set<int>::iterator it=st.begin();
*/
//emplace_back()  等于push_back(),但效率更高,传输pair时emplace_back(i,j)==push_back({i,j}) 
// vector<vector<int>>edge; 二维虚拟储存坐标 
//-----------------------------------------------------------------------------------------------------------------*/
  //map<int,bool>mp[N]; 
  //emplace_back() 
ll dp[2010][2010];//第i天后有j股票的最大收入
ll buy[2010],sell[2010];//买入价，卖出价
ll bm[2010],sm[2010];//最多买入,最多卖出
int main(){
/*cout<<setiosflags(ios::fixed)<<setprecision(8)<<ans<<endl;//输出ans（float）格式控制为8位小数（不含整数部分）*/
/*cout<<setprecision(8)<<ans<<endl;//输出ans（float）格式控制为8位小数（含整数部分）*/
	ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);//同步流
int t,m,w;//天数，持有股票上限，购买天数间隔
cin>>t>>m>>w;
memset(dp,-inf,sizeof(dp));
deque<int>q;
for(int i=1;i<=t;i++){
	cin>>buy[i]>>sell[i]>>bm[i]>>sm[i];//第i天买入价，卖出价，买入上限，卖出上限
	//-----------情况1：今天第一次买入
	for(int j=0;j<=bm[i];j++){
		dp[i][j]=-buy[i]*j;
	}
	//-----------情况2：今天不操作
	for(int j=0;j<=m;j++){
		dp[i][j]=max(dp[i-1][j],dp[i][j]);
	}
	if(i<=w){//小于w天，不足以进行接下来的操作3和4
		continue;
	}
	//-----------情况3：在之前基础上今天买入后有j张股票
	//q中存放第j-w-1天拥有的股票数k，满足q内按dp[i-w-1][k]+k*buy[i]降序
	//因为dp[i][j]=dp[i-w-1][k]-(j-k)*buy[i]=dp[i-w-1][k]+k*buy[i]-j*buy[i],所以队头为最优转移
	for(int j=0;j<=m;j++){
		while(q.size()&&dp[i-w-1][q.back()]+q.back()*buy[i]<=dp[i-w-1][j]+j*buy[i]){//最后的还不如当前更优（q内按dp[i-w-1][k]+k*buy[i]降序）
			q.pop_back();
		}
		q.push_back(j);//放入当前值
		while(q.size()&&q.front()+bm[i]<j){//对于当前j，队首已经超出买的上限，后面必定也超出上限（j递增）
			q.pop_front();
		}
		if(q.size()){
			dp[i][j]=max(dp[i][j],dp[i-w-1][q.front()]-(j-q.front())*buy[i]);//计算当前收入
		}
	}
	q.clear();
	//-----------情况4：在之前基础上今天卖出后有j张股票
	//q中存放第j-w-1天拥有的股票数k，满足q内按dp[i-w-1][k]+k*sell[i]降序
	//因为dp[i][j]=dp[i-w-1][k]+(k-j)*sell[i]=dp[i-w-1][k]+k*sell[i]-j*sell[i],所以队头为最优转移
	for(int j=m;j>=0;j--){//这里得倒序
		while(q.size()&&dp[i-w-1][q.back()]+q.back()*sell[i]<=dp[i-w-1][j]+j*sell[i]){//最后的还不如当前更优（q内按dp[i-w-1][k]+k*sell[i]降序）
			q.pop_back();
		}
		q.push_back(j);//放入当前值
		while(q.size()&&q.front()-sm[i]>j){//对于当前j，队首已经超出卖的上限，后面必定也超出上限(j递减)
			q.pop_front();
		}
		if(q.size()){
			dp[i][j]=max(dp[i][j],dp[i-w-1][q.front()]+(q.front()-j)*sell[i]);//计算当前收入
		}
	}
	q.clear();
}
ll ans=0;//第t天的最大收入
for(int i=0;i<=m;i++){
	ans=max(ans,dp[t][i]);
}
cout<<ans<<endl;
	return 0;
}