hdu 3401 Trade //单调队列+DP

这道题目还是很不错的
首先，我们假定对于某一天的选择是买或卖
那么状态转移方程是
对于买
f[i][j] = max (f[i][j], f[r][k] -  (j - k) * ap[i])  1 <= r <= i - w -1 , max(0, j - as[i]) <= k < j 
对于卖
f[i][j] = max (f[i][j], f[r][k] +  (j - k) * ap[i])  1 <= r <= i - w -1 , min(maxp, j + bs[i]) >k > j
所以对于每个发f[i][j],要枚举1到i-w-1这个范围的值和K值
所以总的时间复杂度是0（maxp*maxp*T*T）
显然时间复杂度不行
开始降维

首先对于状态转移方程，加入一个
f[i][j] = max(f[i][j],f[i-1][j])
这样就可以保证对于f[i][j]，f[i-w-1][]就已经包含了前面所有的最好情况，不用再枚举 1 <= r <= i - w -1这一范围
时间复杂度便成为0（maxp*maxp*T）

还不行
太慢了，还得降维

观察对于f[i][j]
对于他的买这一情况
f[i][j] = max(f[i][j], f[i-w-w][k])   max(0, j - as[i]) <= k < j 
使用单调队列维护后面这一情况，那就对于1到MAXP这一范围进行顺序维护，对于卖的情况是反序维护
具体见代码，现在的时间复杂度就已经降为了0(T*maxp)

#include <cstdio>
#include <cstring>
const int MAXN = 2000 + 123;
int ap[MAXN], bp[MAXN], as[MAXN], bs[MAXN];
int f[MAXN][MAXN];
struct node
{
int num, val;
}q[MAXN];
inline int min(int x,int y)
{
return x<y?x:y;
}
inline int max(int x,int y)
{
return x>y?x:y;
}
int main()
{
int T;
scanf("%d", &T);
while(T--)
{
int t, maxp, w;
scanf("%d%d%d", &t, &maxp, &w);
for(int i = 1; i <= t; i++) scanf("%d%d%d%d",&ap[i], &bp[i], &as[i], &bs[i]);

memset(f, 200, sizeof(f));
for(int i = 1; i <= w + 1; i++)
for(int j = 0; j <= min(as[i], maxp); j++)
{
f[i][j] = -ap[i] * j;
}

for(int i = 2; i <= t; i++)
{
for(int j = 0; j <= maxp; j++) f[i][j] = max(f[i][j], f[i-1][j]);

if(i < w + 2) continue;

int head = 0, tail = -1;
q[++tail].num = 0;
q[tail].val = f[i - w - 1][0];

for(int j = 1; j <= maxp; j++)
{
while(tail >= head && j - q[head].num > as[i]) head++;
//可能全不满足也是有可能的,不可能就保持初始化的0
if(head <= tail) f[i][j] = max(f[i][j], q[head].val - (j - q[head].num) * ap[i]);

while(tail >= head && q[tail].val + (q[tail].num - j) * ap[i] < f[i - w - 1][j]) tail--;
q[++tail].num = j;
q[tail].val = f[i- w - 1][j];
}

head = 0, tail = -1;
q[++tail].num = maxp;
q[tail].val = f[i - w - 1][maxp];

for(int j = maxp - 1; j >= 0; j--)
{
while(tail >= head && q[head].num - j > bs[i]) head++;
if(head <= tail) f[i][j] = max(f[i][j], q[head].val + (q[head].num - j) * bp[i]);

while(tail >= head && q[tail].val + (q[tail].num - j) * bp[i] < f[i - w - 1][j]) tail--;
q[++tail].num = j;
q[tail].val = f[i - w - 1][j];
}
}
int rmax = 0;

for(int i = 0; i <= maxp; i++)
if(f[t][i] > rmax) rmax = f[t][i];
printf("%d\n", rmax);
}
return 0;
}