hdu 3401 Trade 单调队列优化dp

题目链接：

http://acm.hdu.edu.cn/showproblem.php?pid=3401

题目意思：

一个人开始有无穷多的钱，问买股票最多能赚多少钱。

要求：

每天买股票的价格是ap，卖股票的价格是bp。

每天买卖的股票数量有限制as和bs，

交易的时间间隔必须超过w+1天。

最多持有的数量为p股。

解题思路：

dp[i][j]表示前i天当持有j股股票时，获得的最大利益。

状态转移：

当第i天不交易时为dp[i-1][j];

当第i天买(j-k)股时为dp[i-w-1][k]-(j-k)*b[i]   0=<k<=j  //注意要求第i-w----i-1天都不能交易.

     卖(k-j)股时为dp[i-w-1][k]+(k-j)*s[i]     j=<k<=p

当固定某个j时，dp[i-w-1][k]+k*b[i] 是固定的(k,j有个关系），所以可以用单调队列优化。

#include <iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
using namespace std;
const int maxn=2200;
const int inf=0x3f3f3f3f;
int dp[maxn][maxn];
int t,p,w;
struct node
{
    int val,hs;
    node(int h,int v)
    {
        hs=h,val=v;
    }
    node ()
    {

    }
}v[maxn];

int ap[maxn],bp[maxn],as[maxn],bs[maxn];
int main()
{
    int tt;
    scanf("%d",&tt);

    while(tt--)
    {
        scanf("%d%d%d",&t,&p,&w);
        for(int i=1;i<=t;i++)
        {
            scanf("%d%d%d%d",&ap[i],&bp[i],&as[i],&bs[i]);
        }
        memset(dp,-inf,sizeof dp);
        for(int i=1;i<=t;i++)
        {
            for(int j=0;j<=min(as[i],p);j++)
            {
                dp[i][j]=max(dp[i][j],-j*ap[i]);
            }
        }

        for(int i=2;i<=t;i++)
        {
            dp[i][0]=0;
            for(int j=0;j<=p;j++)//no transaction
            {
                dp[i][j]=max(dp[i][j],dp[i-1][j]);
            }
            if(i<w+2)continue;
            int pre=i-w-1;
            int s=0,e=-1;

            for(int j=0;j<=p;j++)//buy j-k,so is from small to big
            {
                int tmp=dp[pre][j]+j*ap[i];
                while(s<=e&&tmp>=v[e].val)//the val is bigger which is better
                {
                    e--;
                }
                node te(j,tmp);
                v[++e]=te;
                while(s<=e&&j-v[s].hs>as[i])
                    s++;
                dp[i][j]=max(dp[i][j],v[s].val-j*ap[i]);
            }

            s=0,e=-1;
            for(int j=p;j>=0;j--)//sell k-j,so is from big to small
            {
                int tmp=dp[pre][j]+j*bp[i];
                while(s<=e&&tmp>=v[e].val)//the val is bigger which is better
                {
                    e--;
                }
                node te(j,tmp);
                v[++e]=te;
                while(s<=e&&v[s].hs-j>bs[i])
                    s++;
                dp[i][j]=max(dp[i][j],v[s].val-j*bp[i]);
            }
        }
        printf("%d\n",dp[t][0]);
    }
}