BZOJ1855 [Scoi2010]股票交易[单调队列dp]

题

题面有点复杂，不概括了。

---

后面的状态有前面的最优解获得大致方向是dp。先是瞎想了个$f[i][j]$表示第$i$天手里有$j$张股票时最大收入（当天无所谓买不买）。

然后写了一个$O(n^4)$状转

$f[i][j]=max(max\{f[k][l]-(j-l)*AP[i]\},max\{f[k][l]+(l-j)*BP[i]\})$

这个很明显就是某一天的前w天之前是可以交易后推到这一天的，因为$i-w~i-1$这些天的状态你也不知道最优解有没有在当天进行交易。那就分为买和卖股票两部分，分别算一下最大利益再合并就行，注意保留不买也不卖的状态。买和卖每天的数量限制就转化为范围。注意题目的意思，一天也是可以既买入又卖出股票的，但是可以发现我们有一部分股票可算作卖出又买回来，这样坑定要亏，那不如不卖了，所以每天要不然买，要不然卖，要不然什么也不做。

验证正确性，写了个40pts暴力

 #include<iostream>
 #include<cstdio>
 #include<algorithm>
 #include<cstring>
 #include<cmath>
 #include<queue>
 #define dbg(x) cerr<<#x<<"="<<x<<endl
 using namespace std;
 typedef long long ll;
 template<typename T>inline char MIN(T&A,T B){return A>B?A=B,:;}
 template<typename T>inline char MAX(T&A,T B){return A<B?A=B,:;}
 template<typename T>inline T _min(T A,T B){return A<B?A:B;}
 template<typename T>inline T _max(T A,T B){return A>B?A:B;}
 template<typename T>inline T read(T&x){
     x=;int f=;char c;while(!isdigit(c=getchar()))if(c=='-')f=;
     while(isdigit(c))x=x*+(c&),c=getchar();return f?x=-x:x;
 }
 const int N=+;const ll INF=1e13;
 ll f[N][N],ans;
 int n,m,w,as,bs,ap,bp;

 int main(){//freopen("test.in","r",stdin);//freopen("tmp.out","w",stdout);
     read(n),read(m),read(w);
     for(register int i=;i<=m;++i)f[][i]=-INF;
     for(register int i=;i<=n;++i){
         read(ap),read(bp),read(as),read(bs);
         for(register int j=;j<=m;++j){
             f[i][j]=-INF;
             for(register int k=;k<=_max(,i-w-);++k){
                 for(register int l=_max(,j-as);l<=j;++l)if(f[k][l]^-INF)MAX(f[i][j],f[k][l]-(j-l)*1ll*ap);
                 for(register int l=j+;l<=_min(m,j+bs);++l)if(f[k][l]^-INF)MAX(f[i][j],f[k][l]+(l-j)*1ll*bp);
             }
             MAX(ans,f[i][j]);
         }
     }
     printf("%lld\n",ans);
     return ;
 }

---

好下面想优化。观察到每一行的每一格算卖出的最大利润可以有前面一些行从这一列开始往后的一块选max转移过来，所以卖出可以倒推dp。我可以分列转移，每一列$l$可行的$k∈[1~i-w-1]$天内找一个$max\{f[k][l]+(l-j)*b\}$即$max\{f[k][l]\}+(l-j)*b$,那我只需要每列维护一个单调栈,保持栈底是j列的f最大值,然后每列直接转移.复杂度$O(n^3)$。再看我每一格是由后面的$bs[i]$格所在列转移的，每列我已经找到一个最优解，那下面我要从这几列（范围内）内找$max\{f[l]+(l-j)*b\}$（$f[l]$为l这一列最大f值）即$max\{f[l]+l*b\}-j*b$，这时就可以用单调队列维护max内那玩意儿了。每行做一次，买入转态同理，从前往后做一遍。同样注意不买不卖的情况应予以保留。复杂度就成了$O(n^2)$。细节看垃圾代码

 #include<iostream>
 #include<cstdio>
 #include<algorithm>
 #include<cstring>
 #include<cmath>
 #include<queue>
 #define dbg(x) cerr<<#x<<"="<<x<<endl
 using namespace std;
 typedef long long ll;
 template<typename T>inline char MIN(T&A,T B){return A>B?A=B,:;}
 template<typename T>inline char MAX(T&A,T B){return A<B?A=B,:;}
 template<typename T>inline T _min(T A,T B){return A<B?A:B;}
 template<typename T>inline T _max(T A,T B){return A>B?A:B;}
 template<typename T>inline T read(T&x){
     x=;int f=;char c;while(!isdigit(c=getchar()))if(c=='-')f=;
     while(isdigit(c))x=x*+(c&),c=getchar();return f?x=-x:x;
 }
 const int N=+;const ll INF=1e13;
 ll f[N][N],ans;
 int q[N],qb[N][N],qa[N][N],ta[N],tb[N];//t--stack's top
 int n,m,w,a,b,A,B,l,r;//a--buy  b--sell  A--buying Bmax stocks  B--selling Smax stocks
 inline ll Fb(int j,int b){return f[qb[j][]][j]+1ll*j*b;}
 inline ll Fa(int j,int a){return f[qa[j][]][j]+1ll*j*a;}

 int main(){//freopen("test.in","r",stdin);//freopen("tmp.out","w",stdout);
     read(n),read(m),read(w);
     for(register int j=;j<=m;++j)f[][j]=-INF;f[][]=;
     for(register int i=;i<=n;++i){
         read(a),read(b),read(A),read(B);
         for(register int j=;j<=m;++j)f[i][j]=-INF;
         l=,r=;
         for(register int j=m;~j;--j){
             if(i>w+){
                 while(tb[j]&&f[qb[j][tb[j]]][j]<=f[i-w-][j])--tb[j];
                 qb[j][++tb[j]]=i-w-;
             }
             while(l<=r&&Fb(q[r],b)<=Fb(j,b))--r;
             q[++r]=j;
             while(l<=r&&q[l]>j+B)++l;
             MAX(f[i][j],Fb(q[l],b)-1ll*j*b);
         }
         l=,r=;
         for(register int j=;j<=m;++j){
             if(i>w+){
                 while(ta[j]&&f[qa[j][ta[j]]][j]<=f[i-w-][j])--ta[j];
                 qa[j][++ta[j]]=i-w-;
             }
             while(l<=r&&Fa(q[r],a)<=Fa(j,a))--r;
             q[++r]=j;
             while(l<=r&&q[l]<j-A)++l;
             MAX(f[i][j],Fa(q[l],a)-1ll*j*a);
             MAX(ans,f[i][j]);
         }
     }
     printf("%lld\n",ans);
     return ;
 }

嗯上边的思路是我个人想的，有部分地方想繁掉了，于是A掉之后看了一眼题解，发现自己真傻。。单调栈完全没必要开出来的。

我要找每一列的合法最大值转移，不用单调栈维护，只要在$f[i-w-1][j]$直接从$f[i-w-2][j]$继承过来就好了，也不会影响合法性，我前一天做了交易，今天不动，所以没事，这样我在这里就保留了j这一列最大f值，因为它来自于上面数行中$fmax$和当前行dp取得的f的最大值。所以一开始朴素方程就是$O(n^3)$的。这个继承获得之前最大值的办法希望记住。