【动态规划】【SCOI2011】股票交易

【题目描述】
最近lxhgww又迷上了投资股票，通过一段时间的观察和学习，他总结出了股票行情的一些规律。
通过一段时间的观察，lxhgww预测到了未来T天内某只股票的走势，第i天的股票买入价为每股APi，第i天的股票卖出价为每股BPi（数据保证对于每个i，都有APi>=BPi），但是每天不能无限制地交易，于是股票交易所规定第i天的一次买入至多只能购买ASi股，一次卖出至多只能卖出BSi股。
另外，股票交易所还制定了两个规定。为了避免大家疯狂交易，股票交易所规定在两次交易（某一天的买入或者卖出均算是一次交易）之间，至少要间隔W天，也就是说如果在第i天发生了交易，那么从第i+1天到第i+W天，均不能发生交易。同时，为了避免垄断，股票交易所还规定在任何时间，一个人的手里的股票数不能超过MaxP。
在第1天之前，lxhgww手里有一大笔钱（可以认为钱的数目无限），但是没有任何股票，当然，T天以后，lxhgww想要赚到最多的钱，聪明的程序员们，你们能帮助他吗？
【输入】
输入数据第一行包括3个整数，分别是T，MaxP，W。
接下来T行，第i行代表第i-1天的股票走势，每行4个整数，分别表示APi，BPi，ASi，BSi。
【输出】
输出数据为一行，包括1个数字，表示lxhgww能赚到的最多的钱数。
【样例输入】
5 2 0
2 1 1 1
2 1 1 1
3 2 1 1
4 3 1 1
5 4 1 1
【样例输出】
    3
【数据范围】
   对于30%的数据，0<=W<T<=50,1<=MaxP<=50
   对于50%的数据，0<=W<T<=2000,1<=MaxP<=50
   对于100%的数据，0<=W<T<=2000,1<=MaxP<=2000

   对于所有的数据，1<=BPi<=APi<=1000,1<=ASi,BSi<=MaxP

此题动态规划的单调队列优化。

朴素的做法如下：
状态：用f[i][j]表示前i天中，最后1天收盘时手中还持有j股的股票所能得到的最大收益。

转移方程：f[i][j] = max{f[i - 1][j],f[i - W - 1][j - k1] - ap[i] * k1,f[i - W - 1][j + k2] + bp[i] * k2}。
其中，k1 <= as[i], k2 <= bs[i]。

以上算法的复杂度是O(T * maxP ^ 2)，显然过不了极限数据。

对于以上转移方程方程，可做如下转化：
令t = i - W - 1，p = j - k1, q = j + k2。
忽略f[i - 1][j]项，则有：
f[i][j] = max{f[t][p] - ap[i] * (j - p),f[t][q] + bp[i] * (q - j)}，
且p >= j - as[i], q <= j + bs[i]。
即f[i][j] = max(f[t][p] + ap[i] * p - ap[i] * j,    (1)
                f[t][q] + bp[i] * q - bp[i] * j}。  (2)
这样一来，可以发现(1)式中，f[t][p] + ap[i] * p部分，和(2)式中f[t][q] + bq[i] * q部分只与p, q有关，于是可以使用单调队列优化。

具体细节见程序注释。
Accode：

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <bitset>

using std::max;

const int maxN = 2010;
const int MAX = 0x3f3f3f3f;
const int MIN = ~MAX;

int F[maxN][maxN];
int q[maxN];
int val[maxN];
int ap, bp, as, bs;
int n, W, Lim, f, r;

int main()
{
	freopen("trade.in", "r", stdin);
	freopen("trade.out", "w", stdout);
    scanf("%d%d%d", &n, &Lim, &W);
    int ans = 0;
    memset(F, 0xc0, sizeof(F));
    F[0][0] = 0;
    for (int i = 1; i < n + 1; ++i)
    {
        scanf("%d%d%d%d", &ap, &bp, &as, &bs);
        for (int j = 0; j < as + 1; ++j) F[i][j] = -ap * j;
	//对于每个i, j都赋一个初始值，
	//否则对于1 <= i <= W就会漏解。
        for (int j = 0; j < Lim + 1; ++j)
            F[i][j] = max(F[i][j], F[i - 1][j]);
	//动态转移方程中的第一项。
        int t = i - W - 1;
        if (t >= 0)
        {
            f = r = 0; //队列清空。
            for (int j = 0; j < Lim + 1; ++j)
            {
                while (f < r && q[f] < j - as) ++f;
		//队中每个元素p都必须满足p >= j - as[i]。
                while (f < r && F[t][j] + j * ap >= val[r - 1])
                    --r;
		//为保证队列的单调性，从右边出队。
                val[r] = F[t][j] + j * ap;
                q[r++] = j;
		//入队。
                if (f < r) F[i][j] = max(F[i][j], val[f] - j * ap);
		//若队列不为空，则更新F[i][j]的值。
            } //Buy.
            f = r = 0;
            for (int j = Lim; j > -1; --j)
            {
                while (f < r && q[f] > j + bs) ++f;
		//队中每个元素p都必须满足p <= j + bs[i]。
                while (f < r && F[t][j] + j * bp >= val[r - 1])
                    --r;
		//为保证队列的单调性，从右边出队。
                val[r] = F[t][j] + j * bp;
                q[r++] = j;
		//入队。
                if (f < r) F[i][j] = max(F[i][j], val[f] - j * bp);
		//若队列不为空，则更新F[i][j]的值。
            } //Sell.
        }
        ans = max(F[i][0], ans);
    }
    printf("%d\n", ans);
	return 0;
}