HDU 3401 Trade dp 单调队列优化

戳这里：3401

题意：给出第 i 天的股票买卖价格（APi，BPi），以及每天股票买卖的数量上限（ASi，BSi），要求任两次交易需要间隔 W 天以上，即第 i 天交易，第 i + W + 1 天才能再交易，求最多能赚多少钱

思路：dp[i][j] = max(dp[i - 1][j], max(dp[f][k] - (j - k) * APi[i]), max(dp[f][k] + (k - j) * BPi[i])); 从式子中观察出，若两天都持有股票数 j 时，之后的那一天所赚的钱不小于之前的那一天，所以可以省去对 f 的枚举，即：

dp[i][j] = max(dp[i - 1][j], max(dp[i - 1 - w][k] - (j - k) * APi[i]), max(dp[i - 1 - w][k] + (k - j) * BPi[i]));

观察到，决策2 j > k，决策3 k > j，且两天所持股票数相近的话，发生状态转移的可能性越大，故可以对 k 进行单调队列优化，

决策2 化为 max(dp[i - 1 - w][k] + k * APi[i]) - j * APi[i]; (j >= k)

决策3 化为 max(dp[i - 1 - w][k] + k * BPi[i]) - j * BPi[i]; (j <= k)

#include "bits/stdc++.h"
using namespace std;
int t;
int T, MaxP, W;
int APi[2010], BPi[2010], ASi[2010], BSi[2010];

int dp[2010][2010];
struct Queue
{
    int value, index;
}q[2010], tmp;
int front, rear;

//dp[i][j] = max(dp[i - 1][j], max(dp[i - 1 - w][k] - (j - k) * APi[i]), max(dp[i - 1 - w][k] + (k - j) * BPi[i]));
//决策2 化为 max(dp[i - 1 - w][k] + k * APi[i]) - j * APi[i]; (j >= k)
//决策3 化为 max(dp[i - 1 - w][k] + k * BPi[i]) - j * BPi[i]; (j <= k)

int main()
{
    scanf("%d", &t);
    while(t--) {
        //初始化
        memset(dp, 0xf3, sizeof(dp));
        //输入
        int i, j, k;
        scanf("%d%d%d", &T, &MaxP, &W);
        for(i = 1; i <= T; ++i) {
            scanf("%d%d%d%d", &APi[i], &BPi[i], &ASi[i], &BSi[i]);
        }
        //处理前驱不完全的状态
        for(i = 1; i <= W + 1; ++i) {
            for(j = 0; j <= ASi[i]; ++j) {  //之前这里写成 j <= MaxP WA了一次
                dp[i][j] = -j * APi[i];
            }
        }
        //从首个后继状态开始 dp
        for(i = 2; i <= T; ++i) {
            //决策1
            for(j = 0; j <= MaxP; ++j) {
                dp[i][j] = max(dp[i][j], dp[i - 1][j]);
            }
            if(i <= W + 1) {
                continue;
            }
            //决策2
            front = rear = 1;
            for(j = 0; j <= MaxP; ++j) {
                tmp.index = j;
                tmp.value = dp[i - 1 - W][j] + j * APi[i];
                for( ; front < rear && tmp.value > q[rear - 1].value; --rear);
                q[rear++] = tmp;
                for( ; front < rear && q[front].index + ASi[i] < j; ++front);
                dp[i][j] = max(dp[i][j], q[front].value - j * APi[i]);
            }
            //决策3
            front = rear = 1;
            for(j = MaxP; j >= 0; j--) {
                tmp.index = j;
                tmp.value = dp[i - 1 - W][j] + j * BPi[i];
                for( ; front < rear && tmp.value > q[rear - 1].value; --rear);
                q[rear++] = tmp;
                for( ; front < rear && q[front].index - BSi[i] > j; ++front);
                dp[i][j] = max(dp[i][j], q[front].value - j * BPi[i]);
            }
        }
        int res = 0;
        for(j = 0; j <= MaxP; ++j) {
            res = max(res, dp[T][j]);
        }
        printf("%d\n", res);
    }
}