hdu 3401(单调队列优化dp)

注意：这题题意是有操作的天数相隔要大于w

然后列出状态转移方程就可以发现，可以用优点队列优化啦。

构造状态dp[i][j]表示第i 天拥有 j只股票的时候，赚了多少钱

状态转移有：

1、从前一天不买不卖:

dp[i][j]=max(dp[i-1][j],dp[i][j])

2、从前i-W-1天买进一些股:

dp[i][j]=max(dp[i-W-1][k]-(j-k)*AP[i],dp[i][j])

3、从i-W-1天卖掉一些股:

dp[i][j]=max(dp[i-W-1][k]+(k-j)*BP[i],dp[i][j])

//
//  main.cpp
//  hdu3401
//
//  Created by New_Life on 16/8/16.
//  Copyright © 2016年 chenhuan001. All rights reserved.
//

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <queue>
#include <string.h>
#include <string>
using namespace std;

#define N 2020
#define INF 100000000

/******************_单调队列模板_******************/
//基于单调队列功能的单一性：以limit为序查找在一定范围内的极值。
//复杂度：O(n)
//用法： 创建的时候调用.init()
//      插入队列:.push( Q_Node( KEY,LIMIT ) );
//      设置limit值:.setlimit( LIMIT );
//      查询<limit值的最大元素: Q_Node qn; q2.top(qn);
//      再查询前需要设置limit值，如果队列为空返回false,否则将最大元素存入qn中并返回true

struct Q_Node {
int key,limit;//用来比较大小的key和控制存在时间的limit
Q_Node(){}
Q_Node(int _key,int _limit){ key=_key,limit=_limit; }
};

struct Q_Que {
Q_Node Q
;
int qf,qd;
int limit;// <limit 的元素将被弹出
void init() {
qf = qd = 0;//将队列内元素清空
}

void push(Q_Node newnode) {//默认入队是当前limit最大的
while (qf>qd && Q[qf-1].key < newnode.key) qf--;
Q[qf++] = newnode;
}

void setlimit(int _limit) {
limit = _limit;
}

/*
取出队列中>=limit且key最大的元素。
*/
bool top(Q_Node &rt)
{
while(qf>qd && Q[qd].limit < limit) qd++;
if(qf==qd) return false;
rt = Q[qd];
return true;
}
}q1,q2;

int dp

;
int ap
,bp
,as
,bs
;

int main(int argc, const char * argv[]) {
int T;
cin>>T;
while(T--)
{
int t,mxp,w;
cin>>t>>mxp>>w;
for(int i=1;i<=t;i++) scanf("%d%d%d%d",ap+i,bp+i,as+i,bs+i);

for(int i=0;i<=t;i++)
for(int j=0;j<=mxp;j++) dp[i][j] = -INF;
for(int i=1;i<=w+1;i++)
for(int j=0;j<=as[i];j++)
dp[i][j] = -j*ap[i];
dp[0][0] = 0;
for(int i=1;i<=t;i++)
{
q1.init(); q2.init();
int sum1=0,sum2=0;
for(int j=0;j<=mxp;j++)
{
dp[i][j] = max(dp[i][j],dp[i-1][j]);//啥也没做
}

if(i <= w+1) continue;
for(int j=0;j<=mxp;j++)
{
q1.push( Q_Node(dp[i-w-1][j]-sum1,j) );
q1.setlimit(j-as[i]);
Q_Node qn;
if(q1.top(qn))
{
dp[i][j] = max(dp[i][j],qn.key+sum1);
}
sum1 -= ap[i];
}

for(int j=mxp;j>=0;j--){
q2.push(Q_Node(dp[i-w-1][j]-sum2, -j));
q2.setlimit(-j-bs[i]);
Q_Node qn;
if(q2.top(qn)) dp[i][j] = max(dp[i][j],qn.key+sum2);
sum2 += bp[i];
}

}
int ans = 0;
for(int i=1;i<=t;i++)
for(int j=0;j<=mxp;j++) ans= max(ans,dp[i][j]);
cout<<ans<<endl;
}
return 0;
}
/*
20
5 2 0
2 1 1 1
2 1 1 1
3 2 1 1
4 3 1 1
5 4 1 1
5 3 0
2 1 2 2
2 1 12 1
3 2 2 1
4 3 3 2
5 4 1 2
5 2 3
2 1 3 2
1 1 12 1
3 2 2 2
4 3 3 3
5 4 1 2
5 3 3
2 1 3 2
1 1 12 1
3 4 2 2
1 3 3 3
1 3 3 5
5 10 0
2 1 3 2
1 1 12 1
3 4 2 2
1 3 3 3
1 3 3 5
5 10 0
2 1 3 2
1 1 12 0
3 4 4 2
1 3 0 3
1 3 0 5
4 1 1
1 1 1 1
1 1 1 1
1 3 1 1
1 3 1 1

10
4 3 1
3 1 1 1
5 1 1 1
10 6 1 1
10 6 1 1

*/